* it's \returns not \Returns

* add some explanations in the typedefs page
* expand a bit the new QuickStartGuide. Some placeholders (not a pb since
it's not even yet linked to from other pages). The point I want to make is
that it's super important to have fully compilable short programs (even
with compile instructions for the first one) not just small snippets, at
least at the beginning. Let's start with examples of compilable programs.

Doxyfile

@@ -5,7 +5,7 @@
 #---------------------------------------------------------------------------
 DOXYFILE_ENCODING      = UTF-8
 PROJECT_NAME           = Eigen
-PROJECT_NUMBER         = 2.0-alpha6
+PROJECT_NUMBER         = 2.0-alpha7
 OUTPUT_DIRECTORY       = ./
 CREATE_SUBDIRS         = NO
 OUTPUT_LANGUAGE        = English

Eigen/src/Core/Matrix.h

@@ -373,8 +373,20 @@ class Matrix : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _MaxRows, _MaxCol
 };
 
 /** \defgroup matrixtypedefs Global matrix typedefs
-  * Eigen defines several typedef shortcuts for most common matrix types.
-  * Here is the explicit list.
+  *
+  * Eigen defines several typedef shortcuts for most common matrix and vector types.
+  *
+  * The general patterns are the following:
+  *
+  * \c MatrixSizeType where \c Size can be \c 2,\c 3,\c 4 for fixed size square matrices or \c X for dynamic size,
+  * and where \c Type can be \c i for integer, \c f for float, \c d for double, \c cf for complex float, \c cd
+  * for complex double.
+  *
+  * For example, \c Matrix3d is a fixed-size 3x3 matrix type of doubles, and \c MatrixXf is a dynamic-size matrix of floats.
+  *
+  * There are also \c VectorSizeType and \c RowVectorSizeType which are self-explanatory. For example, \c Vector4cf is
+  * a fixed-size vector of 4 complex floats.
+  *
   * \sa class Matrix
   */
 

Eigen/src/Geometry/AngleAxis.h

@@ -104,7 +104,7 @@ public:
   operator* (const Matrix3& a, const AngleAxis& b)
   { return a * b.toRotationMatrix(); }
 
-  /** \Returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
+  /** \returns the inverse rotation, i.e., an angle-axis with opposite rotation angle */
   AngleAxis inverse() const
   { return AngleAxis(-m_angle, m_axis); }
 

Eigen/src/Geometry/OrthoMethods.h

@@ -93,7 +93,7 @@ struct ei_someOrthogonal_selector<Derived,2>
   { return VectorType(-ei_conj(src.y()), ei_conj(src.x())).normalized(); }
 };
 
-/** \Returns an orthogonal vector of \c *this
+/** \returns an orthogonal vector of \c *this
   *
   * The size of \c *this must be at least 2. If the size is exactly 2,
   * then the returned vector is a counter clock wise rotation of \c *this, \ie (-y,x).

Eigen/src/Geometry/Rotation.h

@@ -138,10 +138,10 @@ public:
   /** Construct a 2D counter clock wise rotation from the angle \a a in radian. */
   inline Rotation2D(Scalar a) : m_angle(a) {}
 
-  /** \Returns the rotation angle */
+  /** \returns the rotation angle */
   inline Scalar angle() const { return m_angle; }
 
-  /** \Returns a read-write reference to the rotation angle */
+  /** \returns a read-write reference to the rotation angle */
   inline Scalar& angle() { return m_angle; }
 
   /** Automatic convertion to a 2D rotation matrix.
@@ -149,7 +149,7 @@ public:
     */
   inline operator Matrix2() const { return toRotationMatrix(); }
 
-  /** \Returns the inverse rotation */
+  /** \returns the inverse rotation */
   inline Rotation2D inverse() const { return -m_angle; }
 
   /** Concatenates two rotations */

doc/QuickStartGuide.dox

@@ -4,17 +4,52 @@ namespace Eigen {
 
 <h1>Quick start guide</h1>
 
-<h2>Matrix creation and initialization</h2>
+<h2>Simple example with fixed-size matrices and vectors</h2>
+
+By fixed-size, we mean that the number of rows and columns are known at compile-time. In this case, Eigen avoids dynamic memory allocation and unroll loops. This is useful for very small sizes (typically up to 4x4).
+
+<table><tr><td>
+\include Tutorial_simple_example_fixed_size.cpp
+</td>
+<td>
+output:
+\include Tutorial_simple_example_fixed_size.out
+</td></tr></table>
+
+<h2>Simple example with dynamic-size matrices and vectors</h2>
+
+Dynamic-size means that the number of rows and columns are not known at compile-time. In this case, they are stored as runtime variables and the arrays are dynamically allocated.
+
+<table><tr><td>
+\include Tutorial_simple_example_dynamic_size.cpp
+</td>
+<td>
+output:
+\include Tutorial_simple_example_dynamic_size.out
+</td></tr></table>
+
+<h2>Matrix and vector types</h2>
+
+In Eigen, all kinds of dense matrices and vectors are represented by the template class Matrix. In most cases you can simply use one of the several convenient typedefs (\ref matrixtypedefs).
+
+The template class Matrix takes a number of template parameters, but for now it is enough to understand the 3 first ones (and the others can then be left unspecified):
+
+\code Matrix<Scalar, RowsAtCompileTime, ColsAtCompileTime> \endcode
+
+\li \c Scalar is the scalar type, i.e. the type of the coefficients. That is, if you want a vector of floats, choose \c float here.
+\li \c RowsAtCompileTime and \c ColsAtCompileTime are the number of rows and columns of the matrix as known at compile-time. 
+
+For example, \c Vector3d is a typedef for \code Matrix<double, 3, 1> \endcode.
+
+What if the matrix has dynamic-size i.e. the number of rows or cols isn't known at compile-time? Then use the special value Eigen::Dynamic. For example, \c VectorXd is a typedef for \code Matrix<double, Dynamic, 1> \endcode.
+
+<h2>Matrix and vector creation and initialization</h2>
 
-In Eigen all kind of dense matrices and vectors are represented by the template class Matrix.
-For instance \code Matrix<int,Dynamic,4> m(size,4);\endcode declares a matrix of 4 columns
-with a dynamic number of rows.
-However, in most cases you can simply use one of the several convenient typedefs (\ref matrixtypedefs).
 For instance \code Matrix3f m = Matrix3f::Identity(); \endcode creates a 3x3 fixed size matrix of float
 which is initialized to the identity matrix.
 Similarly \code MatrixXcd m = MatrixXcd::Zero(rows,cols); \endcode creates a rows x cols matrix
 of double precision complex which is initialized to zero. Here rows and cols do not have to be
-known at runtime. In "MatrixXcd", "X" stands for dynamic, "c" for complex, and "d" for double.
+known at compile-time. In "MatrixXcd", "X" stands for dynamic, "c" for complex, and "d" for double.
 
 You can also initialize a matrix with all coefficients equal to one:
 \code MatrixXi m = MatrixXi::Ones(rows,cols); \endcode