- get the doc of the enums in MatrixBase right

- get the doc of the flags in Constants right
- finally give up with SEPARATE_MEMBER_PAGES: it triggers too big
  Doxygen bugs, and produces too many small pages. So we have one
  huge page for MatrixBase at currently 300kb and going up, so the
  solution especially for users with low bandwidth will be to provide
  an archive of the html documentation.

Eigen/src/Core/MatrixBase.h

@@ -60,28 +60,26 @@ template<typename Derived> class MatrixBase : public ArrayBase<Derived>
 
     enum {
 
-      RowsAtCompileTime
+      RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime,
         /**< The number of rows at compile-time. This is just a copy of the value provided
           * by the \a Derived type. If a value is not known at compile-time,
           * it is set to the \a Dynamic constant.
           * \sa MatrixBase::rows(), MatrixBase::cols(), ColsAtCompileTime, SizeAtCompileTime */
-        = ei_traits<Derived>::RowsAtCompileTime,
 
-     ColsAtCompileTime
+      ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime,
         /**< The number of columns at compile-time. This is just a copy of the value provided
           * by the \a Derived type. If a value is not known at compile-time,
           * it is set to the \a Dynamic constant.
           * \sa MatrixBase::rows(), MatrixBase::cols(), RowsAtCompileTime, SizeAtCompileTime */
-        = ei_traits<Derived>::ColsAtCompileTime,
         
-      SizeAtCompileTime
+
+      SizeAtCompileTime = (ei_size_at_compile_time<ei_traits<Derived>::RowsAtCompileTime,
+                                                   ei_traits<Derived>::ColsAtCompileTime>::ret),
         /**< This is equal to the number of coefficients, i.e. the number of
           * rows times the number of columns, or to \a Dynamic if this is not
           * known at compile-time. \sa RowsAtCompileTime, ColsAtCompileTime */
-        = ei_size_at_compile_time<ei_traits<Derived>::RowsAtCompileTime,
-                                  ei_traits<Derived>::ColsAtCompileTime>::ret,
       
-      MaxRowsAtCompileTime
+      MaxRowsAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime,
         /**< This value is equal to the maximum possible number of rows that this expression
           * might have. If this expression might have an arbitrarily high number of rows,
           * this value is set to \a Dynamic.
@@ -91,9 +89,8 @@ template<typename Derived> class MatrixBase : public ArrayBase<Derived>
           *
           * \sa RowsAtCompileTime, MaxColsAtCompileTime, MaxSizeAtCompileTime
           */
-        = ei_traits<Derived>::MaxRowsAtCompileTime,
         
-      MaxColsAtCompileTime
+      MaxColsAtCompileTime = ei_traits<Derived>::MaxColsAtCompileTime,
         /**< This value is equal to the maximum possible number of columns that this expression
           * might have. If this expression might have an arbitrarily high number of columns,
           * this value is set to \a Dynamic.
@@ -103,9 +100,9 @@ template<typename Derived> class MatrixBase : public ArrayBase<Derived>
           *
           * \sa ColsAtCompileTime, MaxRowsAtCompileTime, MaxSizeAtCompileTime
           */
-        = ei_traits<Derived>::MaxColsAtCompileTime,
         
-      MaxSizeAtCompileTime
+      MaxSizeAtCompileTime = (ei_size_at_compile_time<ei_traits<Derived>::MaxRowsAtCompileTime,
+                                                      ei_traits<Derived>::MaxColsAtCompileTime>::ret),
         /**< This value is equal to the maximum possible number of coefficients that this expression
           * might have. If this expression might have an arbitrarily high number of coefficients,
           * this value is set to \a Dynamic.
@@ -115,27 +112,23 @@ template<typename Derived> class MatrixBase : public ArrayBase<Derived>
           *
           * \sa SizeAtCompileTime, MaxRowsAtCompileTime, MaxColsAtCompileTime
           */
-        = ei_size_at_compile_time<ei_traits<Derived>::MaxRowsAtCompileTime,
-                                                     ei_traits<Derived>::MaxColsAtCompileTime>::ret,
 
-      IsVectorAtCompileTime
+      IsVectorAtCompileTime = ei_traits<Derived>::RowsAtCompileTime == 1
+                           || ei_traits<Derived>::ColsAtCompileTime == 1,
         /**< This is set to true if either the number of rows or the number of
           * columns is known at compile-time to be equal to 1. Indeed, in that case,
           * we are dealing with a column-vector (if there is only one column) or with
           * a row-vector (if there is only one row). */
-        = ei_traits<Derived>::RowsAtCompileTime == 1 || ei_traits<Derived>::ColsAtCompileTime == 1,
         
-      Flags
+      Flags = ei_traits<Derived>::Flags,
-        /**< This stores expression metadata which typically is inherited by new expressions
+        /**< This stores expression \ref flags flags which may or may not be inherited by new expressions
-          * constructed from this one. The available flags are FIXME!!! document that !!!
+          * constructed from this one. See the \ref flags "list of flags".
           */
-        = ei_traits<Derived>::Flags,
 
-      CoeffReadCost
+      CoeffReadCost = ei_traits<Derived>::CoeffReadCost
         /**< This is a rough measure of how expensive it is to read one coefficient from
           * this expression.
           */
-        = ei_traits<Derived>::CoeffReadCost
     };
 
     /** Default constructor. Just checks at compile-time for self-consistency of the flags. */

Eigen/src/Core/util/Constants.h

@@ -28,24 +28,93 @@
 
 const int Dynamic = 10000;
 
-// matrix/expression flags
+/** \defgroup flags */
+
+/** \name flags
+  *
+  * These are the possible bits which can be OR'ed to constitute the flags of a matrix or
+  * expression.
+  *
+  * \sa MatrixBase::Flags
+  */
+
+/** \ingroup flags
+  *
+  * for a matrix, this means that the storage order is row-major.
+  * If this bit is not set, the storage order is column-major.
+  * For an expression, this determines the storage order of
+  * the matrix created by evaluation of that expression. */
 const unsigned int RowMajorBit = 0x1;
-const unsigned int EvalBeforeNestingBit = 0x2;  ///< means the expression should be evaluated by the calling expression
+
-const unsigned int EvalBeforeAssigningBit = 0x4;///< means the expression should be evaluated before any assignement
+/** \ingroup flags
+  *
+  * means the expression should be evaluated by the calling expression */
+const unsigned int EvalBeforeNestingBit = 0x2;
+
+/** \ingroup flags
+  *
+  * means the expression should be evaluated before any assignement */
+const unsigned int EvalBeforeAssigningBit = 0x4;
+
+/** \ingroup flags
+  *
+  * currently unused. Means the matrix probably has a very big size.
+  * Could eventually be used as a hint to determine which algorithms
+  * to use. */
 const unsigned int LargeBit = 0x8;
+
 #ifdef EIGEN_VECTORIZE
-const unsigned int VectorizableBit = 0x10;  ///< means the expression might be vectorized
+/** \ingroup flags
+  *
+  * means the expression might be vectorized */
+const unsigned int VectorizableBit = 0x10;
 #else
 const unsigned int VectorizableBit = 0x0;
 #endif
-const unsigned int Like1DArrayBit = 0x20;   ///< means the expression can be seen as 1D vector (used for explicit vectorization)
+
-const unsigned int ZeroDiagBit = 0x40;      ///< means all diagonal coefficients are equal to 0
+/** \ingroup flags
-const unsigned int UnitDiagBit = 0x80;      ///< means all diagonal coefficients are equal to 1
+  *
-const unsigned int SelfAdjointBit = 0x100;  ///< means the matrix is selfadjoint (M=M*).
+  * means the expression can be seen as 1D vector (used for explicit vectorization) */
-const unsigned int UpperTriangularBit = 0x200;  ///< means the strictly triangular lower part is 0
+const unsigned int Like1DArrayBit = 0x20;
-const unsigned int LowerTriangularBit = 0x400;  ///< means the strictly triangular upper part is 0
+
-const unsigned int DirectAccessBit = 0x800;     ///< means the underlying matrix data can be direclty accessed
+/** \ingroup flags
-const unsigned int ArrayBit = 0x1000;           ///< means the underlying matrix data can be direclty accessed
+  *
+  * means all diagonal coefficients are equal to 0 */
+const unsigned int ZeroDiagBit = 0x40;      
+
+/** \ingroup flags
+  *
+  * means all diagonal coefficients are equal to 1 */
+const unsigned int UnitDiagBit = 0x80;
+
+/** \ingroup flags
+  *
+  * means the matrix is selfadjoint (M=M*). */
+const unsigned int SelfAdjointBit = 0x100;
+
+/** \ingroup flags
+  *
+  * means the strictly triangular lower part is 0 */
+const unsigned int UpperTriangularBit = 0x200;
+
+/** \ingroup flags
+  *
+  * means the strictly triangular upper part is 0 */
+const unsigned int LowerTriangularBit = 0x400;
+
+/** \ingroup flags
+  *
+  * means the underlying matrix data can be direclty accessed (contrary to certain
+  * expressions where the matrix coefficients need to be computed rather than just read from
+  * memory) */
+const unsigned int DirectAccessBit = 0x800;
+
+/** \ingroup flags
+  *
+  * means the object is just an array of scalars, and operations on it are regarded as operations
+  * on every of these scalars taken separately.
+  */
+const unsigned int ArrayBit = 0x1000;
 
 // list of flags that are inherited by default
 const unsigned int HereditaryBits = RowMajorBit
@@ -67,11 +136,11 @@ const unsigned int UnitLower = LowerTriangularBit | UnitDiagBit;
 const unsigned int Diagonal = Upper | Lower;
 
 
-
 enum { Aligned=0, UnAligned=1 };
 enum { ConditionalJumpCost = 5 };
 enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight };
 enum DirectionType { Vertical, Horizontal };
 enum ProductEvaluationMode { NormalProduct, CacheFriendlyProduct, LazyProduct};
 
+
 #endif // EIGEN_CONSTANTS_H

doc/Doxyfile.in

@@ -182,7 +182,7 @@ INHERIT_DOCS           = YES
 # a new page for each member. If set to NO, the documentation of a member will 
 # be part of the file/class/namespace that contains it.
 
-SEPARATE_MEMBER_PAGES  = YES
+SEPARATE_MEMBER_PAGES  = NO
 
 # The TAB_SIZE tag can be used to set the number of spaces in a tab. 
 # Doxygen uses this value to replace tabs by spaces in code fragments.
@@ -1177,7 +1177,8 @@ INCLUDE_FILE_PATTERNS  =
 # instead of the = operator.
 
 PREDEFINED             = EIGEN_EMPTY_STRUCT \
-                         EIGEN_PARSED_BY_DOXYGEN
+                         EIGEN_PARSED_BY_DOXYGEN \
+                         EIGEN_VECTORIZE
 
 # If the MACRO_EXPANSION and EXPAND_ONLY_PREDEF tags are set to YES then 
 # this tag can be used to specify a list of macro names that should be expanded.