- make RowsAtCompileTime and ColsAtCompileTime public in

MatrixBase and private in derived types
- initial documentation in MatrixBase

src/Core/MatrixBase.h

@@ -26,41 +26,104 @@
 #ifndef EIGEN_MATRIXBASE_H
 #define EIGEN_MATRIXBASE_H
 
+/** \class MatrixBase
+  *
+  * \brief Base class for all matrices, vectors, and expressions
+  *
+  * This class is the base that is inherited by all matrix, vector, and expression
+  * types. Most of the Eigen API is contained in this class.
+  *
+  * This class takes two template parameters:
+  * \param Scalar the type of the coefficients, e.g. float, double, etc.
+  * \param Derived the derived type, e.g. a matrix type, or an expression, etc.
+  * Indeed, a separate MatrixBase type is generated for each derived type
+  * so one knows from inside MatrixBase, at compile-time, what the derived type is.
+  *
+  * When writing a function taking Eigen objects as argument, if you want your function
+  * to take as argument any matrix, vector, or expression, just let it take a
+  * MatrixBase argument. As an example, here is a function printFirstRow which, given
+  * a matrix, vector, or expression \a x, prints the first row of \a x.
+  *
+  * \code
+    template<typename Scalar, typename Derived>
+    void printFirstRow(const Eigen::MatrixBase<Scalar, Derived>& m)
+    {
+      cout << x.row(0) << endl;
+    }
+  * \endcode
+  */
 template<typename Scalar, typename Derived> class MatrixBase
 {
-    static const int RowsAtCompileTime = Derived::RowsAtCompileTime,
-                     ColsAtCompileTime = Derived::ColsAtCompileTime;
-    
   public:
+    /** The number of rows and of columns at compile-time. These are just
+      * copies of the values provided by the \a Derived type. If a value
+      * is not known at compile-time, it is set to the \a Dynamic constant.
+      * \sa rows(), cols(), SizeAtCompileTime */
+    static const int RowsAtCompileTime = Derived::_RowsAtCompileTime,
+                     ColsAtCompileTime = Derived::_ColsAtCompileTime;
+    
+    /** 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 */
     static const int SizeAtCompileTime
       = RowsAtCompileTime == Dynamic || ColsAtCompileTime == Dynamic
       ? Dynamic : RowsAtCompileTime * ColsAtCompileTime;
+    /** 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). */
     static const bool IsVector = RowsAtCompileTime == 1 || ColsAtCompileTime == 1;
     
+    /** This is the "reference type" used to pass objects of type MatrixBase as arguments
+      * to functions. If this MatrixBase type represents an expression, then \a Ref
+      * is just this MatrixBase type itself, i.e. expressions are just passed by value
+      * and the compiler is supposed to be clever enough to optimize that. If, on the
+      * other hand, this MatrixBase type is an actual matrix or vector, then \a Ref is
+      * a typedef MatrixRef, which is like a reference, so that matrices and vectors
+      * are passed by reference, not by value. \sa ref()*/
     typedef typename ForwardDecl<Derived>::Ref Ref;
+    
+    /** This is the "real scalar" type; if the \a Scalar type is already real numbers
+      * (e.g. int, float or double) then RealScalar is just the same as \a Scalar. If
+      * \Scalar is \a std::complex<T> then RealScalar is \a T. */
     typedef typename NumTraits<Scalar>::Real RealScalar;
     
+    /** \returns the number of rows. \sa cols(), RowsAtCompileTime */
     int rows() const { return static_cast<const Derived *>(this)->_rows(); }
+    /** \returns the number of columns. \sa row(), ColsAtCompileTime*/
     int cols() const { return static_cast<const Derived *>(this)->_cols(); }
+    /** \returns the number of coefficients, which is \a rows()*cols().
+      * \sa rows(), cols(). */
     int size() const { return rows() * cols(); }
     
+    /** \returns a Ref to *this. \sa Ref */
     Ref ref() const
     { return static_cast<const Derived *>(this)->_ref(); }
     
+    /** Copies \a other into *this. \returns a reference to *this. */
     template<typename OtherDerived>
     Derived& operator=(const MatrixBase<Scalar, OtherDerived>& other);
     
-    //special case of the above template operator=, in order to prevent the compiler
+    // Special case of the above template operator=, in order to prevent the compiler
     //from generating a default operator= (issue hit with g++ 4.1)
     Derived& operator=(const MatrixBase& other)
     {
       return this->operator=<Derived>(other);
     }
     
+    /** \returns an expression of *this with the \a Scalar type casted to
+      * \a NewScalar. */
     template<typename NewScalar> const Cast<NewScalar, Derived> cast() const;
     
+    /** \returns an expression of the \a i-th row of *this.
+      * \sa col(int)*/
     Row<Derived> row(int i) const;
+    /** \returns an expression of the \a i-th column of *this.
+      * \sa row(int) */
     Column<Derived> col(int i) const;
+    /** \return an expression of the (\a row, \a col)-minor of *this,
+      * i.e. an expression constructed from *this by removing the specified
+      * row and column. */
     Minor<Derived> minor(int row, int col) const;
     
     DynBlock<Derived> dynBlock(int startRow, int startCol,