@smake/eigen 1.1.0 → 1.1.1

package/eigen/Eigen/src/plugins/{BlockMethods.h → BlockMethods.inc}

@@ -18,37 +18,62 @@ typedef Block<Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMaj
 typedef const Block<const Derived, 1, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowXpr;
 /// \internal expression type of a block of whole columns */
 typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ColsBlockXpr;
-typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor> ConstColsBlockXpr;
+typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, Dynamic, !IsRowMajor>
+    ConstColsBlockXpr;
 /// \internal expression type of a block of whole rows */
 typedef Block<Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> RowsBlockXpr;
 typedef const Block<const Derived, Dynamic, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> ConstRowsBlockXpr;
 /// \internal expression type of a block of whole columns */
-template<int N> struct NColsBlockXpr { typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
-template<int N> struct ConstNColsBlockXpr { typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type; };
+template <int N>
+struct NColsBlockXpr {
+  typedef Block<Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type;
+};
+template <int N>
+struct ConstNColsBlockXpr {
+  typedef const Block<const Derived, internal::traits<Derived>::RowsAtCompileTime, N, !IsRowMajor> Type;
+};
 /// \internal expression type of a block of whole rows */
-template<int N> struct NRowsBlockXpr { typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
-template<int N> struct ConstNRowsBlockXpr { typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type; };
+template <int N>
+struct NRowsBlockXpr {
+  typedef Block<Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type;
+};
+template <int N>
+struct ConstNRowsBlockXpr {
+  typedef const Block<const Derived, N, internal::traits<Derived>::ColsAtCompileTime, IsRowMajor> Type;
+};
 /// \internal expression of a block */
 typedef Block<Derived> BlockXpr;
 typedef const Block<const Derived> ConstBlockXpr;
 /// \internal expression of a block of fixed sizes */
-template<int Rows, int Cols> struct FixedBlockXpr { typedef Block<Derived,Rows,Cols> Type; };
-template<int Rows, int Cols> struct ConstFixedBlockXpr { typedef Block<const Derived,Rows,Cols> Type; };
+template <int Rows, int Cols>
+struct FixedBlockXpr {
+  typedef Block<Derived, Rows, Cols> Type;
+};
+template <int Rows, int Cols>
+struct ConstFixedBlockXpr {
+  typedef Block<const Derived, Rows, Cols> Type;
+};
 
 typedef VectorBlock<Derived> SegmentReturnType;
 typedef const VectorBlock<const Derived> ConstSegmentReturnType;
-template<int Size> struct FixedSegmentReturnType { typedef VectorBlock<Derived, Size> Type; };
-template<int Size> struct ConstFixedSegmentReturnType { typedef const VectorBlock<const Derived, Size> Type; };
+template <int Size>
+struct FixedSegmentReturnType {
+  typedef VectorBlock<Derived, Size> Type;
+};
+template <int Size>
+struct ConstFixedSegmentReturnType {
+  typedef const VectorBlock<const Derived, Size> Type;
+};
 
 /// \internal inner-vector
-typedef Block<Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true>       InnerVectorReturnType;
-typedef Block<const Derived,IsRowMajor?1:Dynamic,IsRowMajor?Dynamic:1,true> ConstInnerVectorReturnType;
+typedef Block<Derived, IsRowMajor ? 1 : Dynamic, IsRowMajor ? Dynamic : 1, true> InnerVectorReturnType;
+typedef Block<const Derived, IsRowMajor ? 1 : Dynamic, IsRowMajor ? Dynamic : 1, true> ConstInnerVectorReturnType;
 
 /// \internal set of inner-vectors
-typedef Block<Derived,Dynamic,Dynamic,true> InnerVectorsReturnType;
-typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsReturnType;
+typedef Block<Derived, Dynamic, Dynamic, true> InnerVectorsReturnType;
+typedef Block<const Derived, Dynamic, Dynamic, true> ConstInnerVectorsReturnType;
 
-#endif // not EIGEN_PARSED_BY_DOXYGEN
+#endif  // not EIGEN_PARSED_BY_DOXYGEN
 
 /// \returns an expression of a block in \c *this with either dynamic or fixed sizes.
 ///
@@ -64,16 +89,15 @@ typedef Block<const Derived,Dynamic,Dynamic,true> ConstInnerVectorsReturnType;
 ///
 /// \newin{3.4}:
 ///
-/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
-/// or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value in case \c N equals Eigen::Dynamic.
-/// Here is an example with a fixed number of rows \c NRows and dynamic number of columns \c cols:
-/// \code
-/// mat.block(i,j,fix<NRows>,cols)
-/// \endcode
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing
+/// Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. In the later case, \c n plays the role of a runtime fallback value
+/// in case \c N equals Eigen::Dynamic. Here is an example with a fixed number of rows \c NRows and dynamic number of
+/// columns \c cols: \code mat.block(i,j,fix<NRows>,cols) \endcode
 ///
 /// This function thus fully covers the features offered by the following overloads block<NRows,NCols>(Index, Index),
 /// and block<NRows,NCols>(Index, Index, Index, Index) that are thus obsolete. Indeed, this generic version avoids
-/// redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated code.
+/// redundancy, it preserves the argument order, and prevents the need to rely on the template keyword in templated
+/// code.
 ///
 /// but with less redundancy and more consistency as it does not modify the argument order
 /// and seamlessly enable hybrid fixed/dynamic sizes.
@@ -86,35 +110,40 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa class Block, fix, fix<N>(int)
 ///
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                           internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename FixedBlockXpr<...,...>::Type
+    typename FixedBlockXpr<..., ...>::Type
 #endif
-block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
-{
-  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
-            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+    block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) {
+  return
+      typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                             internal::get_fixed_value<NColsType>::value>::Type(derived(), startRow, startCol,
+                                                                                internal::get_runtime_value(blockRows),
+                                                                                internal::get_runtime_value(blockCols));
 }
 
 /// This is the const version of block(Index,Index,NRowsType,NColsType)
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                      internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstFixedBlockXpr<...,...>::Type
+    const typename ConstFixedBlockXpr<..., ...>::Type
 #endif
-block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const
-{
-  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type(
-            derived(), startRow, startCol, internal::get_runtime_value(blockRows), internal::get_runtime_value(blockCols));
+    block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols) const {
+  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                     internal::get_fixed_value<NColsType>::value>::Type(derived(), startRow, startCol,
+                                                                                        internal::get_runtime_value(
+                                                                                            blockRows),
+                                                                                        internal::get_runtime_value(
+                                                                                            blockCols));
 }
 
-
-
 /// \returns a expression of a top-right corner of \c *this with either dynamic or fixed sizes.
 ///
 /// \param cRows the number of rows in the corner
@@ -125,38 +154,50 @@ block(Index startRow, Index startCol, NRowsType blockRows, NColsType blockCols)
 /// Example with dynamic sizes: \include MatrixBase_topRightCorner_int_int.cpp
 /// Output: \verbinclude MatrixBase_topRightCorner_int_int.out
 ///
-/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
-/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing
+/// Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink
+/// for the details.
 ///
 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                           internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename FixedBlockXpr<...,...>::Type
+    typename FixedBlockXpr<..., ...>::Type
 #endif
-topRightCorner(NRowsType cRows, NColsType cCols)
-{
-  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    topRightCorner(NRowsType cRows, NColsType cCols) {
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                internal::get_fixed_value<NColsType>::value>::Type(derived(), 0,
+                                                                                   cols() - internal::get_runtime_value(
+                                                                                                cCols),
+                                                                                   internal::get_runtime_value(cRows),
+                                                                                   internal::get_runtime_value(cCols));
 }
 
 /// This is the const version of topRightCorner(NRowsType, NColsType).
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                      internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstFixedBlockXpr<...,...>::Type
+    const typename ConstFixedBlockXpr<..., ...>::Type
 #endif
-topRightCorner(NRowsType cRows, NColsType cCols) const
-{
-  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, cols() - internal::get_runtime_value(cCols), internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    topRightCorner(NRowsType cRows, NColsType cCols) const {
+  return
+      typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                  internal::get_fixed_value<NColsType>::value>::Type(derived(), 0,
+                                                                                     cols() -
+                                                                                         internal::get_runtime_value(
+                                                                                             cCols),
+                                                                                     internal::get_runtime_value(cRows),
+                                                                                     internal::get_runtime_value(
+                                                                                         cCols));
 }
 
 /// \returns an expression of a fixed-size top-right corner of \c *this.
@@ -171,19 +212,15 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa class Block, block<int,int>(Index,Index)
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type topRightCorner()
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type topRightCorner() {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), 0, cols() - CCols);
 }
 
 /// This is the const version of topRightCorner<int, int>().
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner() const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - CCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type topRightCorner() const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), 0, cols() - CCols);
 }
 
 /// \returns an expression of a top-right corner of \c *this.
@@ -205,23 +242,19 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa class Block
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols)
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type topRightCorner(Index cRows,
+                                                                                                Index cCols) {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
 }
 
 /// This is the const version of topRightCorner<int, int>(Index, Index).
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows, Index cCols) const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type topRightCorner(
+    Index cRows, Index cCols) const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), 0, cols() - cCols, cRows, cCols);
 }
 
-
-
 /// \returns an expression of a top-left corner of \c *this  with either dynamic or fixed sizes.
 ///
 /// \param cRows the number of rows in the corner
@@ -232,38 +265,45 @@ const typename ConstFixedBlockXpr<CRows,CCols>::Type topRightCorner(Index cRows,
 /// Example: \include MatrixBase_topLeftCorner_int_int.cpp
 /// Output: \verbinclude MatrixBase_topLeftCorner_int_int.out
 ///
-/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
-/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing
+/// Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink
+/// for the details.
 ///
 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                           internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename FixedBlockXpr<...,...>::Type
+    typename FixedBlockXpr<..., ...>::Type
 #endif
-topLeftCorner(NRowsType cRows, NColsType cCols)
-{
-  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    topLeftCorner(NRowsType cRows, NColsType cCols) {
+  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                internal::get_fixed_value<NColsType>::value>::Type(derived(), 0, 0,
+                                                                                   internal::get_runtime_value(cRows),
+                                                                                   internal::get_runtime_value(cCols));
 }
 
 /// This is the const version of topLeftCorner(Index, Index).
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                      internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstFixedBlockXpr<...,...>::Type
+    const typename ConstFixedBlockXpr<..., ...>::Type
 #endif
-topLeftCorner(NRowsType cRows, NColsType cCols) const
-{
-  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, 0, internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    topLeftCorner(NRowsType cRows, NColsType cCols) const {
+  return
+      typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                  internal::get_fixed_value<NColsType>::value>::Type(derived(), 0, 0,
+                                                                                     internal::get_runtime_value(cRows),
+                                                                                     internal::get_runtime_value(
+                                                                                         cCols));
 }
 
 /// \returns an expression of a fixed-size top-left corner of \c *this.
@@ -277,19 +317,15 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner()
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type topLeftCorner() {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), 0, 0);
 }
 
 /// This is the const version of topLeftCorner<int, int>().
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner() const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type topLeftCorner() const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), 0, 0);
 }
 
 /// \returns an expression of a top-left corner of \c *this.
@@ -311,23 +347,19 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa class Block
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols)
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type topLeftCorner(Index cRows,
+                                                                                               Index cCols) {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), 0, 0, cRows, cCols);
 }
 
 /// This is the const version of topLeftCorner<int, int>(Index, Index).
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows, Index cCols) const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), 0, 0, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type topLeftCorner(
+    Index cRows, Index cCols) const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), 0, 0, cRows, cCols);
 }
 
-
-
 /// \returns an expression of a bottom-right corner of \c *this  with either dynamic or fixed sizes.
 ///
 /// \param cRows the number of rows in the corner
@@ -338,40 +370,45 @@ const typename ConstFixedBlockXpr<CRows,CCols>::Type topLeftCorner(Index cRows,
 /// Example: \include MatrixBase_bottomRightCorner_int_int.cpp
 /// Output: \verbinclude MatrixBase_bottomRightCorner_int_int.out
 ///
-/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
-/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing
+/// Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink
+/// for the details.
 ///
 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                           internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename FixedBlockXpr<...,...>::Type
+    typename FixedBlockXpr<..., ...>::Type
 #endif
-bottomRightCorner(NRowsType cRows, NColsType cCols)
-{
-  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
-                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    bottomRightCorner(NRowsType cRows, NColsType cCols) {
+  return
+      typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value, internal::get_fixed_value<NColsType>::value>::
+          Type(derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
+               internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
 }
 
 /// This is the const version of bottomRightCorner(NRowsType, NColsType).
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                      internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstFixedBlockXpr<...,...>::Type
+    const typename ConstFixedBlockXpr<..., ...>::Type
 #endif
-bottomRightCorner(NRowsType cRows, NColsType cCols) const
-{
-  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), rows() - internal::get_runtime_value(cRows), cols() - internal::get_runtime_value(cCols),
-                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    bottomRightCorner(NRowsType cRows, NColsType cCols) const {
+  return typename ConstFixedBlockXpr<
+      internal::get_fixed_value<NRowsType>::value,
+      internal::get_fixed_value<NColsType>::value>::Type(derived(), rows() - internal::get_runtime_value(cRows),
+                                                         cols() - internal::get_runtime_value(cCols),
+                                                         internal::get_runtime_value(cRows),
+                                                         internal::get_runtime_value(cCols));
 }
 
 /// \returns an expression of a fixed-size bottom-right corner of \c *this.
@@ -385,19 +422,15 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner()
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type bottomRightCorner() {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), rows() - CRows, cols() - CCols);
 }
 
 /// This is the const version of bottomRightCorner<int, int>().
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner() const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, cols() - CCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type bottomRightCorner() const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), rows() - CRows, cols() - CCols);
 }
 
 /// \returns an expression of a bottom-right corner of \c *this.
@@ -419,23 +452,19 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa class Block
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols)
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type bottomRightCorner(Index cRows,
+                                                                                                   Index cCols) {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
 }
 
 /// This is the const version of bottomRightCorner<int, int>(Index, Index).
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRows, Index cCols) const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type bottomRightCorner(
+    Index cRows, Index cCols) const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), rows() - cRows, cols() - cCols, cRows, cCols);
 }
 
-
-
 /// \returns an expression of a bottom-left corner of \c *this  with either dynamic or fixed sizes.
 ///
 /// \param cRows the number of rows in the corner
@@ -446,40 +475,47 @@ const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomRightCorner(Index cRo
 /// Example: \include MatrixBase_bottomLeftCorner_int_int.cpp
 /// Output: \verbinclude MatrixBase_bottomLeftCorner_int_int.out
 ///
-/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing Eigen::fix<N>,
-/// or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
+/// The number of rows \a blockRows and columns \a blockCols can also be specified at compile-time by passing
+/// Eigen::fix<N>, or Eigen::fix<N>(n) as arguments. See \link block(Index,Index,NRowsType,NColsType) block() \endlink
+/// for the details.
 ///
 EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                           internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename FixedBlockXpr<...,...>::Type
+    typename FixedBlockXpr<..., ...>::Type
 #endif
-bottomLeftCorner(NRowsType cRows, NColsType cCols)
-{
-  return typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), rows() - internal::get_runtime_value(cRows), 0,
-                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    bottomLeftCorner(NRowsType cRows, NColsType cCols) {
+  return
+      typename FixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                             internal::get_fixed_value<NColsType>::value>::Type(derived(),
+                                                                                rows() -
+                                                                                    internal::get_runtime_value(cRows),
+                                                                                0, internal::get_runtime_value(cRows),
+                                                                                internal::get_runtime_value(cCols));
 }
 
 /// This is the const version of bottomLeftCorner(NRowsType, NColsType).
-template<typename NRowsType, typename NColsType>
+template <typename NRowsType, typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
+    typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,
+                                internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename ConstFixedBlockXpr<...,...>::Type
+    typename ConstFixedBlockXpr<..., ...>::Type
 #endif
-bottomLeftCorner(NRowsType cRows, NColsType cCols) const
-{
-  return typename ConstFixedBlockXpr<internal::get_fixed_value<NRowsType>::value,internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), rows() - internal::get_runtime_value(cRows), 0,
-                        internal::get_runtime_value(cRows), internal::get_runtime_value(cCols));
+    bottomLeftCorner(NRowsType cRows, NColsType cCols) const {
+  return typename ConstFixedBlockXpr<
+      internal::get_fixed_value<NRowsType>::value,
+      internal::get_fixed_value<NColsType>::value>::Type(derived(), rows() - internal::get_runtime_value(cRows), 0,
+                                                         internal::get_runtime_value(cRows),
+                                                         internal::get_runtime_value(cCols));
 }
 
 /// \returns an expression of a fixed-size bottom-left corner of \c *this.
@@ -493,19 +529,15 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner()
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type bottomLeftCorner() {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), rows() - CRows, 0);
 }
 
 /// This is the const version of bottomLeftCorner<int, int>().
-template<int CRows, int CCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner() const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - CRows, 0);
+template <int CRows, int CCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type bottomLeftCorner() const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), rows() - CRows, 0);
 }
 
 /// \returns an expression of a bottom-left corner of \c *this.
@@ -527,23 +559,18 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa class Block
 ///
-template<int CRows, int CCols>
-EIGEN_STRONG_INLINE
-typename FixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols)
-{
-  return typename FixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_STRONG_INLINE typename FixedBlockXpr<CRows, CCols>::Type bottomLeftCorner(Index cRows, Index cCols) {
+  return typename FixedBlockXpr<CRows, CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
 }
 
 /// This is the const version of bottomLeftCorner<int, int>(Index, Index).
-template<int CRows, int CCols>
-EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRows, Index cCols) const
-{
-  return typename ConstFixedBlockXpr<CRows,CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
+template <int CRows, int CCols>
+EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<CRows, CCols>::Type bottomLeftCorner(Index cRows,
+                                                                                           Index cCols) const {
+  return typename ConstFixedBlockXpr<CRows, CCols>::Type(derived(), rows() - cRows, 0, cRows, cCols);
 }
 
-
-
 /// \returns a block consisting of the top rows of \c *this.
 ///
 /// \param n the number of rows in the block
@@ -556,35 +583,33 @@ const typename ConstFixedBlockXpr<CRows,CCols>::Type bottomLeftCorner(Index cRow
 /// or Eigen::fix<N>(n) as arguments.
 /// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType>
+template <typename NRowsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+    typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
 #else
-typename NRowsBlockXpr<...>::Type
+    typename NRowsBlockXpr<...>::Type
 #endif
-topRows(NRowsType n)
-{
-  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
-            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+    topRows(NRowsType n) {
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type(
+      derived(), 0, 0, internal::get_runtime_value(n), cols());
 }
 
 /// This is the const version of topRows(NRowsType).
-template<typename NRowsType>
+template <typename NRowsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+    const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
 #else
-const typename ConstNRowsBlockXpr<...>::Type
+    const typename ConstNRowsBlockXpr<...>::Type
 #endif
-topRows(NRowsType n) const
-{
-  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
-            (derived(), 0, 0, internal::get_runtime_value(n), cols());
+    topRows(NRowsType n) const {
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type(
+      derived(), 0, 0, internal::get_runtime_value(n), cols());
 }
 
 /// \returns a block consisting of the top rows of \c *this.
@@ -598,27 +623,21 @@ topRows(NRowsType n) const
 /// Example: \include MatrixBase_template_int_topRows.cpp
 /// Output: \verbinclude MatrixBase_template_int_topRows.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename NRowsBlockXpr<N>::Type topRows(Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NRowsBlockXpr<N>::Type topRows(Index n = N) {
   return typename NRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
 }
 
 /// This is the const version of topRows<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const {
   return typename ConstNRowsBlockXpr<N>::Type(derived(), 0, 0, n, cols());
 }
 
-
-
 /// \returns a block consisting of the bottom rows of \c *this.
 ///
 /// \param n the number of rows in the block
@@ -631,35 +650,33 @@ typename ConstNRowsBlockXpr<N>::Type topRows(Index n = N) const
 /// or Eigen::fix<N>(n) as arguments.
 /// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType>
+template <typename NRowsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+    typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
 #else
-typename NRowsBlockXpr<...>::Type
+    typename NRowsBlockXpr<...>::Type
 #endif
-bottomRows(NRowsType n)
-{
-  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
-            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+    bottomRows(NRowsType n) {
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type(
+      derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
 }
 
 /// This is the const version of bottomRows(NRowsType).
-template<typename NRowsType>
+template <typename NRowsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+    const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
 #else
-const typename ConstNRowsBlockXpr<...>::Type
+    const typename ConstNRowsBlockXpr<...>::Type
 #endif
-bottomRows(NRowsType n) const
-{
-  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
-            (derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
+    bottomRows(NRowsType n) const {
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type(
+      derived(), rows() - internal::get_runtime_value(n), 0, internal::get_runtime_value(n), cols());
 }
 
 /// \returns a block consisting of the bottom rows of \c *this.
@@ -673,27 +690,21 @@ bottomRows(NRowsType n) const
 /// Example: \include MatrixBase_template_int_bottomRows.cpp
 /// Output: \verbinclude MatrixBase_template_int_bottomRows.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename NRowsBlockXpr<N>::Type bottomRows(Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NRowsBlockXpr<N>::Type bottomRows(Index n = N) {
   return typename NRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
 }
 
 /// This is the const version of bottomRows<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const {
   return typename ConstNRowsBlockXpr<N>::Type(derived(), rows() - n, 0, n, cols());
 }
 
-
-
 /// \returns a block consisting of a range of rows of \c *this.
 ///
 /// \param startRow the index of the first row in the block
@@ -707,35 +718,33 @@ typename ConstNRowsBlockXpr<N>::Type bottomRows(Index n = N) const
 /// or Eigen::fix<N>(n) as arguments.
 /// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NRowsType>
+template <typename NRowsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+    typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
 #else
-typename NRowsBlockXpr<...>::Type
+    typename NRowsBlockXpr<...>::Type
 #endif
-middleRows(Index startRow, NRowsType n)
-{
-  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
-            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+    middleRows(Index startRow, NRowsType n) {
+  return typename NRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type(
+      derived(), startRow, 0, internal::get_runtime_value(n), cols());
 }
 
 /// This is the const version of middleRows(Index,NRowsType).
-template<typename NRowsType>
+template <typename NRowsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
+    const typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
 #else
-const typename ConstNRowsBlockXpr<...>::Type
+    const typename ConstNRowsBlockXpr<...>::Type
 #endif
-middleRows(Index startRow, NRowsType n) const
-{
-  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type
-            (derived(), startRow, 0, internal::get_runtime_value(n), cols());
+    middleRows(Index startRow, NRowsType n) const {
+  return typename ConstNRowsBlockXpr<internal::get_fixed_value<NRowsType>::value>::Type(
+      derived(), startRow, 0, internal::get_runtime_value(n), cols());
 }
 
 /// \returns a block consisting of a range of rows of \c *this.
@@ -750,27 +759,22 @@ middleRows(Index startRow, NRowsType n) const
 /// Example: \include DenseBase_template_int_middleRows.cpp
 /// Output: \verbinclude DenseBase_template_int_middleRows.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) {
   return typename NRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
 }
 
 /// This is the const version of middleRows<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow,
+                                                                                      Index n = N) const {
   return typename ConstNRowsBlockXpr<N>::Type(derived(), startRow, 0, n, cols());
 }
 
-
-
 /// \returns a block consisting of the left columns of \c *this.
 ///
 /// \param n the number of columns in the block
@@ -783,35 +787,33 @@ typename ConstNRowsBlockXpr<N>::Type middleRows(Index startRow, Index n = N) con
 /// or Eigen::fix<N>(n) as arguments.
 /// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NColsType>
+template <typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+    typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename NColsBlockXpr<...>::Type
+    typename NColsBlockXpr<...>::Type
 #endif
-leftCols(NColsType n)
-{
-  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+    leftCols(NColsType n) {
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type(derived(), 0, 0, rows(),
+                                                                                   internal::get_runtime_value(n));
 }
 
 /// This is the const version of leftCols(NColsType).
-template<typename NColsType>
+template <typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstNColsBlockXpr<...>::Type
+    const typename ConstNColsBlockXpr<...>::Type
 #endif
-leftCols(NColsType n) const
-{
-  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, 0, rows(), internal::get_runtime_value(n));
+    leftCols(NColsType n) const {
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type(derived(), 0, 0, rows(),
+                                                                                        internal::get_runtime_value(n));
 }
 
 /// \returns a block consisting of the left columns of \c *this.
@@ -825,27 +827,21 @@ leftCols(NColsType n) const
 /// Example: \include MatrixBase_template_int_leftCols.cpp
 /// Output: \verbinclude MatrixBase_template_int_leftCols.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename NColsBlockXpr<N>::Type leftCols(Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NColsBlockXpr<N>::Type leftCols(Index n = N) {
   return typename NColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
 }
 
 /// This is the const version of leftCols<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const {
   return typename ConstNColsBlockXpr<N>::Type(derived(), 0, 0, rows(), n);
 }
 
-
-
 /// \returns a block consisting of the right columns of \c *this.
 ///
 /// \param n the number of columns in the block
@@ -858,35 +854,33 @@ typename ConstNColsBlockXpr<N>::Type leftCols(Index n = N) const
 /// or Eigen::fix<N>(n) as arguments.
 /// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NColsType>
+template <typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+    typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename NColsBlockXpr<...>::Type
+    typename NColsBlockXpr<...>::Type
 #endif
-rightCols(NColsType n)
-{
-  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+    rightCols(NColsType n) {
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type(
+      derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
 }
 
 /// This is the const version of rightCols(NColsType).
-template<typename NColsType>
+template <typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstNColsBlockXpr<...>::Type
+    const typename ConstNColsBlockXpr<...>::Type
 #endif
-rightCols(NColsType n) const
-{
-  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
+    rightCols(NColsType n) const {
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type(
+      derived(), 0, cols() - internal::get_runtime_value(n), rows(), internal::get_runtime_value(n));
 }
 
 /// \returns a block consisting of the right columns of \c *this.
@@ -900,27 +894,21 @@ rightCols(NColsType n) const
 /// Example: \include MatrixBase_template_int_rightCols.cpp
 /// Output: \verbinclude MatrixBase_template_int_rightCols.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename NColsBlockXpr<N>::Type rightCols(Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NColsBlockXpr<N>::Type rightCols(Index n = N) {
   return typename NColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
 }
 
 /// This is the const version of rightCols<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const {
   return typename ConstNColsBlockXpr<N>::Type(derived(), 0, cols() - n, rows(), n);
 }
 
-
-
 /// \returns a block consisting of a range of columns of \c *this.
 ///
 /// \param startCol the index of the first column in the block
@@ -934,35 +922,33 @@ typename ConstNColsBlockXpr<N>::Type rightCols(Index n = N) const
 /// or Eigen::fix<N>(n) as arguments.
 /// See \link block(Index,Index,NRowsType,NColsType) block() \endlink for the details.
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<typename NColsType>
+template <typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+    typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
 #else
-typename NColsBlockXpr<...>::Type
+    typename NColsBlockXpr<...>::Type
 #endif
-middleCols(Index startCol, NColsType numCols)
-{
-  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+    middleCols(Index startCol, NColsType numCols) {
+  return typename NColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type(
+      derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
 }
 
 /// This is the const version of middleCols(Index,NColsType).
-template<typename NColsType>
+template <typename NColsType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
+    const typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
 #else
-const typename ConstNColsBlockXpr<...>::Type
+    const typename ConstNColsBlockXpr<...>::Type
 #endif
-middleCols(Index startCol, NColsType numCols) const
-{
-  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type
-            (derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
+    middleCols(Index startCol, NColsType numCols) const {
+  return typename ConstNColsBlockXpr<internal::get_fixed_value<NColsType>::value>::Type(
+      derived(), 0, startCol, rows(), internal::get_runtime_value(numCols));
 }
 
 /// \returns a block consisting of a range of columns of \c *this.
@@ -977,27 +963,22 @@ middleCols(Index startCol, NColsType numCols) const
 /// Example: \include DenseBase_template_int_middleCols.cpp
 /// Output: \verbinclude DenseBase_template_int_middleCols.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename NColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) {
   return typename NColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
 }
 
 /// This is the const version of middleCols<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol, Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstNColsBlockXpr<N>::Type middleCols(Index startCol,
+                                                                                      Index n = N) const {
   return typename ConstNColsBlockXpr<N>::Type(derived(), 0, startCol, rows(), n);
 }
 
-
-
 /// \returns a fixed-size expression of a block of \c *this.
 ///
 /// The template parameters \a NRows and \a NCols are the number of
@@ -1022,19 +1003,16 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int NRows, int NCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol)
-{
-  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+template <int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<NRows, NCols>::Type block(Index startRow, Index startCol) {
+  return typename FixedBlockXpr<NRows, NCols>::Type(derived(), startRow, startCol);
 }
 
 /// This is the const version of block<>(Index, Index). */
-template<int NRows, int NCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol) const
-{
-  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol);
+template <int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<NRows, NCols>::Type block(
+    Index startRow, Index startCol) const {
+  return typename ConstFixedBlockXpr<NRows, NCols>::Type(derived(), startRow, startCol);
 }
 
 /// \returns an expression of a block of \c *this.
@@ -1068,21 +1046,18 @@ EIGEN_DOC_BLOCK_ADDONS_NOT_INNER_PANEL
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), class Block
 ///
-template<int NRows, int NCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
-                                                  Index blockRows, Index blockCols)
-{
-  return typename FixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+template <int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedBlockXpr<NRows, NCols>::Type block(Index startRow, Index startCol,
+                                                                                       Index blockRows,
+                                                                                       Index blockCols) {
+  return typename FixedBlockXpr<NRows, NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
 }
 
 /// This is the const version of block<>(Index, Index, Index, Index).
-template<int NRows, int NCols>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index startCol,
-                                                              Index blockRows, Index blockCols) const
-{
-  return typename ConstFixedBlockXpr<NRows,NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
+template <int NRows, int NCols>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const typename ConstFixedBlockXpr<NRows, NCols>::Type block(
+    Index startRow, Index startCol, Index blockRows, Index blockCols) const {
+  return typename ConstFixedBlockXpr<NRows, NCols>::Type(derived(), startRow, startCol, blockRows, blockCols);
 }
 
 /// \returns an expression of the \a i-th column of \c *this. Note that the numbering starts at 0.
@@ -1090,42 +1065,26 @@ const typename ConstFixedBlockXpr<NRows,NCols>::Type block(Index startRow, Index
 /// Example: \include MatrixBase_col.cpp
 /// Output: \verbinclude MatrixBase_col.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(column - major)
 /**
-  * \sa row(), class Block */
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-ColXpr col(Index i)
-{
-  return ColXpr(derived(), i);
-}
+ * \sa row(), class Block */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ColXpr col(Index i) { return ColXpr(derived(), i); }
 
 /// This is the const version of col().
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-ConstColXpr col(Index i) const
-{
-  return ConstColXpr(derived(), i);
-}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ConstColXpr col(Index i) const { return ConstColXpr(derived(), i); }
 
 /// \returns an expression of the \a i-th row of \c *this. Note that the numbering starts at 0.
 ///
 /// Example: \include MatrixBase_row.cpp
 /// Output: \verbinclude MatrixBase_row.out
 ///
-EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row-major)
+EIGEN_DOC_BLOCK_ADDONS_INNER_PANEL_IF(row - major)
 /**
-  * \sa col(), class Block */
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-RowXpr row(Index i)
-{
-  return RowXpr(derived(), i);
-}
+ * \sa col(), class Block */
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE RowXpr row(Index i) { return RowXpr(derived(), i); }
 
 /// This is the const version of row(). */
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-ConstRowXpr row(Index i) const
-{
-  return ConstRowXpr(derived(), i);
-}
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE ConstRowXpr row(Index i) const { return ConstRowXpr(derived(), i); }
 
 /// \returns an expression of a segment (i.e. a vector block) in \c *this with either dynamic or fixed sizes.
 ///
@@ -1148,34 +1107,31 @@ ConstRowXpr row(Index i) const
 ///
 /// \sa block(Index,Index,NRowsType,NColsType), fix<N>, fix<N>(int), class Block
 ///
-template<typename NType>
+template <typename NType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+    typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
 #else
-typename FixedSegmentReturnType<...>::Type
+    typename FixedSegmentReturnType<...>::Type
 #endif
-segment(Index start, NType n)
-{
+    segment(Index start, NType n) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
-            (derived(), start, internal::get_runtime_value(n));
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type(derived(), start,
+                                                                                        internal::get_runtime_value(n));
 }
 
-
 /// This is the const version of segment(Index,NType).
-template<typename NType>
+template <typename NType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+    const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
 #else
-const typename ConstFixedSegmentReturnType<...>::Type
+    const typename ConstFixedSegmentReturnType<...>::Type
 #endif
-segment(Index start, NType n) const
-{
+    segment(Index start, NType n) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
-            (derived(), start, internal::get_runtime_value(n));
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type(
+      derived(), start, internal::get_runtime_value(n));
 }
 
 /// \returns an expression of the first coefficients of \c *this with either dynamic or fixed sizes.
@@ -1198,33 +1154,31 @@ segment(Index start, NType n) const
 ///
 /// \sa class Block, block(Index,Index)
 ///
-template<typename NType>
+template <typename NType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+    typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
 #else
-typename FixedSegmentReturnType<...>::Type
+    typename FixedSegmentReturnType<...>::Type
 #endif
-head(NType n)
-{
+    head(NType n) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
-              (derived(), 0, internal::get_runtime_value(n));
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type(derived(), 0,
+                                                                                        internal::get_runtime_value(n));
 }
 
 /// This is the const version of head(NType).
-template<typename NType>
+template <typename NType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+    const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
 #else
-const typename ConstFixedSegmentReturnType<...>::Type
+    const typename ConstFixedSegmentReturnType<...>::Type
 #endif
-head(NType n) const
-{
+    head(NType n) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
-            (derived(), 0, internal::get_runtime_value(n));
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type(
+      derived(), 0, internal::get_runtime_value(n));
 }
 
 /// \returns an expression of a last coefficients of \c *this with either dynamic or fixed sizes.
@@ -1247,33 +1201,31 @@ head(NType n) const
 ///
 /// \sa class Block, block(Index,Index)
 ///
-template<typename NType>
+template <typename NType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+    typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
 #else
-typename FixedSegmentReturnType<...>::Type
+    typename FixedSegmentReturnType<...>::Type
 #endif
-tail(NType n)
-{
+    tail(NType n) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
-            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+  return typename FixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type(
+      derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
 }
 
 /// This is the const version of tail(Index).
-template<typename NType>
+template <typename NType>
 EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
 #ifndef EIGEN_PARSED_BY_DOXYGEN
-const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
+    const typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
 #else
-const typename ConstFixedSegmentReturnType<...>::Type
+    const typename ConstFixedSegmentReturnType<...>::Type
 #endif
-tail(NType n) const
-{
+    tail(NType n) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type
-            (derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
+  return typename ConstFixedSegmentReturnType<internal::get_fixed_value<NType>::value>::Type(
+      derived(), this->size() - internal::get_runtime_value(n), internal::get_runtime_value(n));
 }
 
 /// \returns a fixed-size expression of a segment (i.e. a vector block) in \c *this
@@ -1292,19 +1244,16 @@ tail(NType n) const
 ///
 /// \sa segment(Index,NType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedSegmentReturnType<N>::Type segment(Index start, Index n = N) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
   return typename FixedSegmentReturnType<N>::Type(derived(), start, n);
 }
 
 /// This is the const version of segment<int>(Index).
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstFixedSegmentReturnType<N>::Type segment(Index start,
+                                                                                            Index n = N) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
   return typename ConstFixedSegmentReturnType<N>::Type(derived(), start, n);
 }
@@ -1324,19 +1273,15 @@ typename ConstFixedSegmentReturnType<N>::Type segment(Index start, Index n = N)
 ///
 /// \sa head(NType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedSegmentReturnType<N>::Type head(Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedSegmentReturnType<N>::Type head(Index n = N) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
   return typename FixedSegmentReturnType<N>::Type(derived(), 0, n);
 }
 
 /// This is the const version of head<int>().
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
   return typename ConstFixedSegmentReturnType<N>::Type(derived(), 0, n);
 }
@@ -1356,87 +1301,70 @@ typename ConstFixedSegmentReturnType<N>::Type head(Index n = N) const
 ///
 /// \sa tail(NType), class Block
 ///
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename FixedSegmentReturnType<N>::Type tail(Index n = N)
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename FixedSegmentReturnType<N>::Type tail(Index n = N) {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n);
+  return typename FixedSegmentReturnType<N>::Type(derived(), size() - n, n);
 }
 
 /// This is the const version of tail<int>.
-template<int N>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const
-{
+template <int N>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE typename ConstFixedSegmentReturnType<N>::Type tail(Index n = N) const {
   EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n);
+  return typename ConstFixedSegmentReturnType<N>::Type(derived(), size() - n, n);
 }
 
 /// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
 /// is col-major (resp. row-major).
 ///
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-InnerVectorReturnType innerVector(Index outer)
-{ return InnerVectorReturnType(derived(), outer); }
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE InnerVectorReturnType innerVector(Index outer) {
+  return InnerVectorReturnType(derived(), outer);
+}
 
 /// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
 /// is col-major (resp. row-major). Read-only.
 ///
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const ConstInnerVectorReturnType innerVector(Index outer) const
-{ return ConstInnerVectorReturnType(derived(), outer); }
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ConstInnerVectorReturnType innerVector(Index outer) const {
+  return ConstInnerVectorReturnType(derived(), outer);
+}
 
 /// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
 /// is col-major (resp. row-major).
 ///
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-InnerVectorsReturnType
-innerVectors(Index outerStart, Index outerSize)
-{
-  return Block<Derived,Dynamic,Dynamic,true>(derived(),
-                                             IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
-                                             IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
-
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE InnerVectorsReturnType innerVectors(Index outerStart, Index outerSize) {
+  return Block<Derived, Dynamic, Dynamic, true>(derived(), IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
+                                                IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
 }
 
 /// \returns the \a outer -th column (resp. row) of the matrix \c *this if \c *this
 /// is col-major (resp. row-major). Read-only.
 ///
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-const ConstInnerVectorsReturnType
-innerVectors(Index outerStart, Index outerSize) const
-{
-  return Block<const Derived,Dynamic,Dynamic,true>(derived(),
-                                                  IsRowMajor ? outerStart : 0, IsRowMajor ? 0 : outerStart,
-                                                  IsRowMajor ? outerSize : rows(), IsRowMajor ? cols() : outerSize);
-
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE const ConstInnerVectorsReturnType innerVectors(Index outerStart,
+                                                                                     Index outerSize) const {
+  return Block<const Derived, Dynamic, Dynamic, true>(derived(), IsRowMajor ? outerStart : 0,
+                                                      IsRowMajor ? 0 : outerStart, IsRowMajor ? outerSize : rows(),
+                                                      IsRowMajor ? cols() : outerSize);
 }
 
 /** \returns the i-th subvector (column or vector) according to the \c Direction
-  * \sa subVectors()
-  */
-template<DirectionType Direction>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type
-subVector(Index i)
-{
-  return typename internal::conditional<Direction==Vertical,ColXpr,RowXpr>::type(derived(),i);
+ * \sa subVectors()
+ */
+template <DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::conditional_t<Direction == Vertical, ColXpr, RowXpr> subVector(Index i) {
+  return std::conditional_t<Direction == Vertical, ColXpr, RowXpr>(derived(), i);
 }
 
 /** This is the const version of subVector(Index) */
-template<DirectionType Direction>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
-typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type
-subVector(Index i) const
-{
-  return typename internal::conditional<Direction==Vertical,ConstColXpr,ConstRowXpr>::type(derived(),i);
+template <DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE std::conditional_t<Direction == Vertical, ConstColXpr, ConstRowXpr> subVector(
+    Index i) const {
+  return std::conditional_t<Direction == Vertical, ConstColXpr, ConstRowXpr>(derived(), i);
 }
 
 /** \returns the number of subvectors (rows or columns) in the direction \c Direction
-  * \sa subVector(Index)
-  */
-template<DirectionType Direction>
-EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE EIGEN_CONSTEXPR
-Index subVectors() const
-{ return (Direction==Vertical)?cols():rows(); }
+ * \sa subVector(Index)
+ */
+template <DirectionType Direction>
+EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE constexpr Index subVectors() const {
+  return (Direction == Vertical) ? cols() : rows();
+}