some documentation fixes (Cwise* and Cholesky)

Eigen/src/Cholesky/Cholesky.h

@@ -109,7 +109,7 @@ void Cholesky<MatrixType>::compute(const MatrixType& a)
 
 /** \returns the solution of A x = \a b using the current decomposition of A.
   * In other words, it returns \code A^-1 b \endcode computing
-  * \code L^-*  L^1 b \code from right to left.
+  * \code L^-*  L^1 b \endcode from right to left.
   */
 template<typename MatrixType>
 template<typename Derived>

Eigen/src/Cholesky/CholeskyWithoutSquareRoot.h

@@ -119,9 +119,10 @@ void CholeskyWithoutSquareRoot<MatrixType>::compute(const MatrixType& a)
   }
 }
 
-/** \returns the solution of A x = \a b using the current decomposition of A.
-  * In other words, it returns \code A^-1 b \endcode computing
-  * \code (L^-*) (D^-1) (L^-1) b \code from right to left.
+/** \returns the solution of \f$ A x = b \f$ using the current decomposition of A.
+  * In other words, it returns \f$ A^{-1} b \f$ computing
+  * \f$ {L^{*}}^{-1} D^{-1} L^{-1} b \f$ from right to left.
+  * \param vecB the vector \f$ b \f$  (or an array of vectors)
   */
 template<typename MatrixType>
 template<typename Derived>

Eigen/src/Core/CwiseBinaryOp.h

@@ -41,10 +41,7 @@
   * However, if you want to write a function returning such an expression, you
   * will need to use this class.
   *
-  * Here is an example illustrating this:
-  * \include class_CwiseBinaryOp.cpp
-  *
-  * \sa class ei_scalar_product_op, class ei_scalar_quotient_op
+  * \sa MatrixBase::cwise(const MatrixBase<OtherDerived> &,const CustomBinaryOp &) const, class CwiseUnaryOp, class CwiseNullaryOp
   */
 template<typename BinaryOp, typename Lhs, typename Rhs>
 struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
@@ -220,6 +217,10 @@ MatrixBase<Derived>::cwiseMax(const MatrixBase<OtherDerived> &other) const
   * The template parameter \a CustomBinaryOp is the type of the functor
   * of the custom operator (see class CwiseBinaryOp for an example)
   *
+  * Here is an example illustrating the use of custom functors:
+  * \include class_CwiseBinaryOp.cpp
+  * Output: \verbinclude class_CwiseBinaryOp.out
+  *
   * \sa class CwiseBinaryOp, MatrixBase::operator+, MatrixBase::operator-, MatrixBase::cwiseProduct, MatrixBase::cwiseQuotient
   */
 template<typename Derived>

Eigen/src/Core/CwiseNullaryOp.h

@@ -38,6 +38,7 @@
   * However, if you want to write a function returning such an expression, you
   * will need to use this class.
   *
+  * \sa class CwiseUnaryOp, class CwiseBinaryOp, MatrixBase::create()
   */
 template<typename NullaryOp, typename MatrixType>
 struct ei_traits<CwiseNullaryOp<NullaryOp, MatrixType> >

Eigen/src/Core/CwiseUnaryOp.h

@@ -37,7 +37,7 @@
   * It is the return type of the unary operator-, of a matrix or a vector, and most
   * of the time this is the only way it is used.
   *
-  * \sa class CwiseBinaryOp
+  * \sa MatrixBase::cwise(const CustomUnaryOp &) const, class CwiseBinaryOp, class CwiseNullaryOp
   */
 template<typename UnaryOp, typename MatrixType>
 struct ei_traits<CwiseUnaryOp<UnaryOp, MatrixType> >
@@ -100,6 +100,7 @@ class CwiseUnaryOp : ei_no_assignment_operator,
   *
   * Here is an example:
   * \include class_CwiseUnaryOp.cpp
+  * Output: \verbinclude class_CwiseUnaryOp.out
   *
   * \sa class CwiseUnaryOp, class CwiseBinarOp, MatrixBase::operator-, MatrixBase::cwiseAbs
   */

bench/BenchTimer.h

@@ -39,10 +39,11 @@ class BenchTimer
 {
 public:
 
-  BenchTimer() : m_best(1e99) {}
+  BenchTimer() : m_best(1e12) {}
 
   ~BenchTimer() {}
 
+  inline void reset(void) {m_best = 1e12;}
   inline void start(void) {m_start = getTime();}
   inline void stop(void)
   {

doc/Doxyfile.in

@@ -143,6 +143,7 @@ DISABLE_INDEX          = NO
 ENUM_VALUES_PER_LINE   = 1
 GENERATE_TREEVIEW      = NO
 TREEVIEW_WIDTH         = 250
+FORMULA_FONTSIZE       = 12
 #---------------------------------------------------------------------------
 # configuration options related to the LaTeX output
 #---------------------------------------------------------------------------

doc/examples/class_CwiseBinaryOp.cpp

@@ -1,29 +1,17 @@
-// FIXME - this example is not too good as that functionality is provided in the Eigen API
-// additionally it's quite heavy. the CwiseUnaryOp example is better.
-
 #include <Eigen/Core>
 USING_PART_OF_NAMESPACE_EIGEN
 using namespace std;
 
 // define a custom template binary functor
-template<typename Scalar> struct CwiseMinOp EIGEN_EMPTY_STRUCT {
-    Scalar operator()(const Scalar& a, const Scalar& b) const { return std::min(a,b); }
-    enum { Cost = Eigen::ConditionalJumpCost + Eigen::NumTraits<Scalar>::AddCost };
+template<typename Scalar> struct MakeComplexOp EIGEN_EMPTY_STRUCT {
+  typedef complex<Scalar> result_type;
+  complex<Scalar> operator()(const Scalar& a, const Scalar& b) const { return complex<Scalar>(a,b); }
+  enum { Cost = 0 };
 };
 
-// define a custom binary operator between two matrices
-template<typename Derived1, typename Derived2>
-const Eigen::CwiseBinaryOp<CwiseMinOp<typename Derived1::Scalar>, Derived1, Derived2>
-cwiseMin(const MatrixBase<Derived1> &mat1, const MatrixBase<Derived2> &mat2)
-{
-  return Eigen::CwiseBinaryOp<CwiseMinOp<typename Derived1::Scalar>, Derived1, Derived2>(mat1, mat2);
-}
-
 int main(int, char**)
 {
   Matrix4d m1 = Matrix4d::random(), m2 = Matrix4d::random();
-  cout << cwiseMin(m1,m2) << endl;            // use our new global operator
-  cout << m1.cwise<CwiseMinOp<double> >(m2) << endl;   // directly use the generic expression member
-  cout << m1.cwise(m2, CwiseMinOp<double>()) << endl; // directly use the generic expression member (variant)
+  cout << m1.cwise(m2, MakeComplexOp<double>()) << endl;
   return 0;
 }

doc/examples/class_CwiseUnaryOp.cpp

@@ -2,9 +2,9 @@
 USING_PART_OF_NAMESPACE_EIGEN
 using namespace std;
 
-// define a custom template binary functor
+// define a custom template unary functor
 template<typename Scalar>
-struct CwiseClampOp EIGEN_EMPTY_STRUCT {
+struct CwiseClampOp {
   CwiseClampOp(const Scalar& inf, const Scalar& sup) : m_inf(inf), m_sup(sup) {}
   const Scalar operator()(const Scalar& x) const { return x<m_inf ? m_inf : (x>m_sup ? m_sup : x); }
   Scalar m_inf, m_sup;
@@ -14,6 +14,6 @@ struct CwiseClampOp EIGEN_EMPTY_STRUCT {
 int main(int, char**)
 {
   Matrix4d m1 = Matrix4d::random();
-  cout << m1.cwise(CwiseClampOp<double>(-0.5,0.5)) << endl;
+  cout << m1 << endl << "becomes: " << endl << m1.cwise(CwiseClampOp<double>(-0.5,0.5)) << endl;
   return 0;
 }