From afc64f3332941653a52faa7d441c6af1adbaccc7 Mon Sep 17 00:00:00 2001
From: Benoit Jacob <jacob.benoit.1@gmail.com>
Date: Thu, 13 Mar 2008 09:33:26 +0000
Subject: a lot of renaming internal classes: AaBb -> ei_aa_bb
 IntAtRunTimeIfDynamic -> ei_int_if_dynamic unify UNROLLING_LIMIT (there was
 no reason to have operator= use a higher limit) etc...

---
 Eigen/src/Core/Block.h               | 10 +++----
 Eigen/src/Core/CwiseBinaryOp.h       | 35 ++++++++++--------------
 Eigen/src/Core/CwiseUnaryOp.h        | 52 +++++++++++++++++------------------
 Eigen/src/Core/DiagonalCoeffs.h      |  2 +-
 Eigen/src/Core/DiagonalMatrix.h      |  4 +--
 Eigen/src/Core/Dot.h                 | 18 ++++++------
 Eigen/src/Core/Eval.h                |  4 +--
 Eigen/src/Core/EvalOMP.h             |  4 +--
 Eigen/src/Core/ForwardDeclarations.h | 16 ++++++-----
 Eigen/src/Core/Identity.h            |  8 +++---
 Eigen/src/Core/Map.h                 |  2 +-
 Eigen/src/Core/Matrix.h              |  4 +--
 Eigen/src/Core/MatrixBase.h          | 22 +++++++--------
 Eigen/src/Core/MatrixRef.h           |  2 +-
 Eigen/src/Core/MatrixStorage.h       | 47 ++++++++++++++++----------------
 Eigen/src/Core/Minor.h               |  2 +-
 Eigen/src/Core/Ones.h                |  8 +++---
 Eigen/src/Core/OperatorEquals.h      | 32 +++++++++++-----------
 Eigen/src/Core/Product.h             | 20 +++++++-------
 Eigen/src/Core/Random.h              |  8 +++---
 Eigen/src/Core/Trace.h               | 16 +++++------
 Eigen/src/Core/Transpose.h           |  6 ++--
 Eigen/src/Core/Util.h                | 53 +++++++++++++++---------------------
 Eigen/src/Core/Zero.h                |  8 +++---
 bench/bench_unrolling                |  2 +-
 doc/examples/class_Cast.cpp          |  6 ++--
 test/submatrices.cpp                 |  2 +-
 27 files changed, 190 insertions(+), 203 deletions(-)

diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h
index a2a581aac..7b504239a 100644
--- a/Eigen/src/Core/Block.h
+++ b/Eigen/src/Core/Block.h
@@ -75,7 +75,7 @@ template<typename MatrixType, int BlockRows, int BlockCols> class Block
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Block)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Block)
 
     typedef typename MatrixType::AsArg MatRef;
 
@@ -142,10 +142,10 @@ template<typename MatrixType, int BlockRows, int BlockCols> class Block
   protected:
 
     MatRef m_matrix;
-    IntAtRunTimeIfDynamic<MatrixType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
-    IntAtRunTimeIfDynamic<MatrixType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
-    IntAtRunTimeIfDynamic<RowsAtCompileTime> m_blockRows;
-    IntAtRunTimeIfDynamic<ColsAtCompileTime> m_blockCols;
+    ei_int_if_dynamic<MatrixType::RowsAtCompileTime == 1 ? 0 : Dynamic> m_startRow;
+    ei_int_if_dynamic<MatrixType::ColsAtCompileTime == 1 ? 0 : Dynamic> m_startCol;
+    ei_int_if_dynamic<RowsAtCompileTime> m_blockRows;
+    ei_int_if_dynamic<ColsAtCompileTime> m_blockCols;
 };
 
 /** \returns a dynamic-size expression of a block in *this.
diff --git a/Eigen/src/Core/CwiseBinaryOp.h b/Eigen/src/Core/CwiseBinaryOp.h
index 63e0fbac0..7478f6256 100644
--- a/Eigen/src/Core/CwiseBinaryOp.h
+++ b/Eigen/src/Core/CwiseBinaryOp.h
@@ -44,7 +44,7 @@
   * Here is an example illustrating this:
   * \include class_CwiseBinaryOp.cpp
   *
-  * \sa class ScalarProductOp, class ScalarQuotientOp
+  * \sa class ei_scalar_product_op, class ei_scalar_quotient_op
   */
 template<typename BinaryOp, typename Lhs, typename Rhs>
 struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
@@ -64,12 +64,12 @@ struct ei_traits<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
 };
 
 template<typename BinaryOp, typename Lhs, typename Rhs>
-class CwiseBinaryOp : NoOperatorEquals,
+class CwiseBinaryOp : ei_no_assignment_operator,
   public MatrixBase<CwiseBinaryOp<BinaryOp, Lhs, Rhs> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(CwiseBinaryOp)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseBinaryOp)
 
     typedef typename Lhs::AsArg LhsRef;
     typedef typename Rhs::AsArg RhsRef;
@@ -102,7 +102,7 @@ class CwiseBinaryOp : NoOperatorEquals,
   *
   * \sa class CwiseBinaryOp, MatrixBase::operator+
   */
-struct ScalarSumOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_sum_op EIGEN_EMPTY_STRUCT {
     template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a + b; }
 };
 
@@ -111,7 +111,7 @@ struct ScalarSumOp EIGEN_EMPTY_STRUCT {
   *
   * \sa class CwiseBinaryOp, MatrixBase::operator-
   */
-struct ScalarDifferenceOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_difference_op EIGEN_EMPTY_STRUCT {
     template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a - b; }
 };
 
@@ -120,7 +120,7 @@ struct ScalarDifferenceOp EIGEN_EMPTY_STRUCT {
   *
   * \sa class CwiseBinaryOp, MatrixBase::cwiseProduct()
   */
-struct ScalarProductOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_product_op EIGEN_EMPTY_STRUCT {
     template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a * b; }
 };
 
@@ -129,7 +129,7 @@ struct ScalarProductOp EIGEN_EMPTY_STRUCT {
   *
   * \sa class CwiseBinaryOp, MatrixBase::cwiseQuotient()
   */
-struct ScalarQuotientOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_quotient_op EIGEN_EMPTY_STRUCT {
     template<typename Scalar> Scalar operator() (const Scalar& a, const Scalar& b) const { return a / b; }
 };
 
@@ -140,10 +140,10 @@ struct ScalarQuotientOp EIGEN_EMPTY_STRUCT {
   * \sa class CwiseBinaryOp, MatrixBase::operator-=()
   */
 template<typename Derived1, typename Derived2>
-const CwiseBinaryOp<ScalarDifferenceOp, Derived1, Derived2>
+const CwiseBinaryOp<ei_scalar_difference_op, Derived1, Derived2>
 operator-(const MatrixBase<Derived1> &mat1, const MatrixBase<Derived2> &mat2)
 {
-  return CwiseBinaryOp<ScalarDifferenceOp, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
+  return CwiseBinaryOp<ei_scalar_difference_op, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
 }
 
 /** replaces \c *this by \c *this - \a other.
@@ -158,7 +158,6 @@ MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
   return *this = *this - other;
 }
 
-
 /** \relates MatrixBase
   *
   * \returns an expression of the sum of \a mat1 and \a mat2
@@ -166,10 +165,10 @@ MatrixBase<Derived>::operator-=(const MatrixBase<OtherDerived> &other)
   * \sa class CwiseBinaryOp, MatrixBase::operator+=()
   */
 template<typename Derived1, typename Derived2>
-const CwiseBinaryOp<ScalarSumOp, Derived1, Derived2>
+const CwiseBinaryOp<ei_scalar_sum_op, Derived1, Derived2>
 operator+(const MatrixBase<Derived1> &mat1, const MatrixBase<Derived2> &mat2)
 {
-  return CwiseBinaryOp<ScalarSumOp, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
+  return CwiseBinaryOp<ei_scalar_sum_op, Derived1, Derived2>(mat1.asArg(), mat2.asArg());
 }
 
 /** replaces \c *this by \c *this + \a other.
@@ -184,33 +183,30 @@ MatrixBase<Derived>::operator+=(const MatrixBase<OtherDerived>& other)
   return *this = *this + other;
 }
 
-
 /** \returns an expression of the Schur product (coefficient wise product) of *this and \a other
   *
   * \sa class CwiseBinaryOp
   */
 template<typename Derived>
 template<typename OtherDerived>
-const CwiseBinaryOp<ScalarProductOp, Derived, OtherDerived>
+const CwiseBinaryOp<ei_scalar_product_op, Derived, OtherDerived>
 MatrixBase<Derived>::cwiseProduct(const MatrixBase<OtherDerived> &other) const
 {
-  return CwiseBinaryOp<ScalarProductOp, Derived, OtherDerived>(asArg(), other.asArg());
+  return CwiseBinaryOp<ei_scalar_product_op, Derived, OtherDerived>(asArg(), other.asArg());
 }
 
-
 /** \returns an expression of the coefficient-wise quotient of *this and \a other
   *
   * \sa class CwiseBinaryOp
   */
 template<typename Derived>
 template<typename OtherDerived>
-const CwiseBinaryOp<ScalarQuotientOp, Derived, OtherDerived>
+const CwiseBinaryOp<ei_scalar_quotient_op, Derived, OtherDerived>
 MatrixBase<Derived>::cwiseQuotient(const MatrixBase<OtherDerived> &other) const
 {
-  return CwiseBinaryOp<ScalarQuotientOp, Derived, OtherDerived>(asArg(), other.asArg());
+  return CwiseBinaryOp<ei_scalar_quotient_op, Derived, OtherDerived>(asArg(), other.asArg());
 }
 
-
 /** \returns an expression of a custom coefficient-wise operator \a func of *this and \a other
   *
   * The template parameter \a CustomBinaryOp is the type of the functor
@@ -226,5 +222,4 @@ MatrixBase<Derived>::cwise(const MatrixBase<OtherDerived> &other, const CustomBi
   return CwiseBinaryOp<CustomBinaryOp, Derived, OtherDerived>(asArg(), other.asArg(), func);
 }
 
-
 #endif // EIGEN_CWISE_BINARY_OP_H
diff --git a/Eigen/src/Core/CwiseUnaryOp.h b/Eigen/src/Core/CwiseUnaryOp.h
index a2ad55aef..5fe2293e2 100644
--- a/Eigen/src/Core/CwiseUnaryOp.h
+++ b/Eigen/src/Core/CwiseUnaryOp.h
@@ -54,12 +54,12 @@ struct ei_traits<CwiseUnaryOp<UnaryOp, MatrixType> >
 };
 
 template<typename UnaryOp, typename MatrixType>
-class CwiseUnaryOp : NoOperatorEquals,
+class CwiseUnaryOp : ei_no_assignment_operator,
   public MatrixBase<CwiseUnaryOp<UnaryOp, MatrixType> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(CwiseUnaryOp)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(CwiseUnaryOp)
 
     typedef typename MatrixType::AsArg MatRef;
 
@@ -86,7 +86,7 @@ class CwiseUnaryOp : NoOperatorEquals,
   *
   * \sa class CwiseUnaryOp, MatrixBase::operator-
   */
-struct ScalarOppositeOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_opposite_op EIGEN_EMPTY_STRUCT {
   template<typename Scalar> Scalar operator() (const Scalar& a) const { return -a; }
 };
 
@@ -95,7 +95,7 @@ struct ScalarOppositeOp EIGEN_EMPTY_STRUCT {
   *
   * \sa class CwiseUnaryOp, MatrixBase::cwiseAbs
   */
-struct ScalarAbsOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_abs_op EIGEN_EMPTY_STRUCT {
   template<typename Scalar> Scalar operator() (const Scalar& a) const { return ei_abs(a); }
 };
 
@@ -103,19 +103,19 @@ struct ScalarAbsOp EIGEN_EMPTY_STRUCT {
 /** \returns an expression of the opposite of \c *this
   */
 template<typename Derived>
-const CwiseUnaryOp<ScalarOppositeOp,Derived>
+const CwiseUnaryOp<ei_scalar_opposite_op,Derived>
 MatrixBase<Derived>::operator-() const
 {
-  return CwiseUnaryOp<ScalarOppositeOp,Derived>(asArg());
+  return CwiseUnaryOp<ei_scalar_opposite_op,Derived>(asArg());
 }
 
 /** \returns an expression of the opposite of \c *this
   */
 template<typename Derived>
-const CwiseUnaryOp<ScalarAbsOp,Derived>
+const CwiseUnaryOp<ei_scalar_abs_op,Derived>
 MatrixBase<Derived>::cwiseAbs() const
 {
-  return CwiseUnaryOp<ScalarAbsOp,Derived>(asArg());
+  return CwiseUnaryOp<ei_scalar_abs_op,Derived>(asArg());
 }
 
 
@@ -143,7 +143,7 @@ MatrixBase<Derived>::cwise(const CustomUnaryOp& func) const
   *
   * \sa class CwiseUnaryOp, MatrixBase::conjugate()
   */
-struct ScalarConjugateOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_conjugate_op EIGEN_EMPTY_STRUCT {
     template<typename Scalar> Scalar operator() (const Scalar& a) const { return ei_conj(a); }
 };
 
@@ -151,10 +151,10 @@ struct ScalarConjugateOp EIGEN_EMPTY_STRUCT {
   *
   * \sa adjoint() */
 template<typename Derived>
-const CwiseUnaryOp<ScalarConjugateOp, Derived>
+const CwiseUnaryOp<ei_scalar_conjugate_op, Derived>
 MatrixBase<Derived>::conjugate() const
 {
-  return CwiseUnaryOp<ScalarConjugateOp, Derived>(asArg());
+  return CwiseUnaryOp<ei_scalar_conjugate_op, Derived>(asArg());
 }
 
 /** \internal
@@ -163,7 +163,7 @@ MatrixBase<Derived>::conjugate() const
   * \sa class CwiseUnaryOp, MatrixBase::cast()
   */
 template<typename NewType>
-struct ScalarCastOp EIGEN_EMPTY_STRUCT {
+struct ei_scalar_cast_op EIGEN_EMPTY_STRUCT {
     typedef NewType result_type;
     template<typename Scalar> NewType operator() (const Scalar& a) const { return static_cast<NewType>(a); }
 };
@@ -176,14 +176,14 @@ struct ScalarCastOp EIGEN_EMPTY_STRUCT {
   * Example: \include MatrixBase_cast.cpp
   * Output: \verbinclude MatrixBase_cast.out
   *
-  * \sa class CwiseUnaryOp, class ScalarCastOp
+  * \sa class CwiseUnaryOp, class ei_scalar_cast_op
   */
 template<typename Derived>
 template<typename NewType>
-const CwiseUnaryOp<ScalarCastOp<NewType>, Derived>
+const CwiseUnaryOp<ei_scalar_cast_op<NewType>, Derived>
 MatrixBase<Derived>::cast() const
 {
-  return CwiseUnaryOp<ScalarCastOp<NewType>, Derived>(asArg());
+  return CwiseUnaryOp<ei_scalar_cast_op<NewType>, Derived>(asArg());
 }
 
 /** \internal
@@ -192,31 +192,31 @@ MatrixBase<Derived>::cast() const
   * \sa class CwiseUnaryOp, MatrixBase::operator*, MatrixBase::operator/
   */
 template<typename Scalar>
-struct ScalarMultipleOp {
-    ScalarMultipleOp(const Scalar& other) : m_other(other) {}
+struct ei_scalar_multiple_op {
+    ei_scalar_multiple_op(const Scalar& other) : m_other(other) {}
     Scalar operator() (const Scalar& a) const { return a * m_other; }
     const Scalar m_other;
 };
 
-/** \relates MatrixBase \sa class ScalarMultipleOp */
+/** \relates MatrixBase \sa class ei_scalar_multiple_op */
 template<typename Derived>
-const CwiseUnaryOp<ScalarMultipleOp<typename ei_traits<Derived>::Scalar>, Derived>
+const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
 MatrixBase<Derived>::operator*(const Scalar& scalar) const
 {
-  return CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived>(asArg(), ScalarMultipleOp<Scalar>(scalar));
+  return CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>(asArg(), ei_scalar_multiple_op<Scalar>(scalar));
 }
 
-/** \relates MatrixBase \sa class ScalarMultipleOp */
+/** \relates MatrixBase \sa class ei_scalar_multiple_op */
 template<typename Derived>
-const CwiseUnaryOp<ScalarMultipleOp<typename ei_traits<Derived>::Scalar>, Derived>
+const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
 MatrixBase<Derived>::operator/(const Scalar& scalar) const
 {
   assert(NumTraits<Scalar>::HasFloatingPoint);
-  return CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived>
-    (asArg(), ScalarMultipleOp<Scalar>(static_cast<Scalar>(1) / scalar));
+  return CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>
+    (asArg(), ei_scalar_multiple_op<Scalar>(static_cast<Scalar>(1) / scalar));
 }
 
-/** \sa ScalarMultipleOp */
+/** \sa ei_scalar_multiple_op */
 template<typename Derived>
 Derived&
 MatrixBase<Derived>::operator*=(const Scalar& other)
@@ -224,7 +224,7 @@ MatrixBase<Derived>::operator*=(const Scalar& other)
   return *this = *this * other;
 }
 
-/** \sa ScalarMultipleOp */
+/** \sa ei_scalar_multiple_op */
 template<typename Derived>
 Derived&
 MatrixBase<Derived>::operator/=(const Scalar& other)
diff --git a/Eigen/src/Core/DiagonalCoeffs.h b/Eigen/src/Core/DiagonalCoeffs.h
index e8bc04108..0eea3f93b 100644
--- a/Eigen/src/Core/DiagonalCoeffs.h
+++ b/Eigen/src/Core/DiagonalCoeffs.h
@@ -58,7 +58,7 @@ template<typename MatrixType> class DiagonalCoeffs
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(DiagonalCoeffs)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(DiagonalCoeffs)
 
     typedef typename MatrixType::AsArg MatRef;
 
diff --git a/Eigen/src/Core/DiagonalMatrix.h b/Eigen/src/Core/DiagonalMatrix.h
index e27d2c366..fc381a048 100644
--- a/Eigen/src/Core/DiagonalMatrix.h
+++ b/Eigen/src/Core/DiagonalMatrix.h
@@ -51,12 +51,12 @@ struct ei_traits<DiagonalMatrix<CoeffsVectorType> >
 };
 
 template<typename CoeffsVectorType>
-class DiagonalMatrix : NoOperatorEquals,
+class DiagonalMatrix : ei_no_assignment_operator,
   public MatrixBase<DiagonalMatrix<CoeffsVectorType> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(DiagonalMatrix)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(DiagonalMatrix)
 
     typedef typename CoeffsVectorType::AsArg CoeffsVecRef;
 
diff --git a/Eigen/src/Core/Dot.h b/Eigen/src/Core/Dot.h
index f4d13e517..4147dee56 100644
--- a/Eigen/src/Core/Dot.h
+++ b/Eigen/src/Core/Dot.h
@@ -26,17 +26,17 @@
 #define EIGEN_DOT_H
 
 template<int Index, int Size, typename Derived1, typename Derived2>
-struct DotUnroller
+struct ei_dot_unroller
 {
   static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
   {
-    DotUnroller<Index-1, Size, Derived1, Derived2>::run(v1, v2, dot);
+    ei_dot_unroller<Index-1, Size, Derived1, Derived2>::run(v1, v2, dot);
     dot += v1.coeff(Index) * ei_conj(v2.coeff(Index));
   }
 };
 
 template<int Size, typename Derived1, typename Derived2>
-struct DotUnroller<0, Size, Derived1, Derived2>
+struct ei_dot_unroller<0, Size, Derived1, Derived2>
 {
   static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
   {
@@ -45,14 +45,14 @@ struct DotUnroller<0, Size, Derived1, Derived2>
 };
 
 template<int Index, typename Derived1, typename Derived2>
-struct DotUnroller<Index, Dynamic, Derived1, Derived2>
+struct ei_dot_unroller<Index, Dynamic, Derived1, Derived2>
 {
   static void run(const Derived1&, const Derived2&, typename Derived1::Scalar&) {}
 };
 
 // prevent buggy user code from causing an infinite recursion
 template<int Index, typename Derived1, typename Derived2>
-struct DotUnroller<Index, 0, Derived1, Derived2>
+struct ei_dot_unroller<Index, 0, Derived1, Derived2>
 {
   static void run(const Derived1&, const Derived2&, typename Derived1::Scalar&) {}
 };
@@ -78,9 +78,9 @@ MatrixBase<Derived>::dot(const MatrixBase<OtherDerived>& other) const
   Scalar res;
   if(EIGEN_UNROLLED_LOOPS
   && SizeAtCompileTime != Dynamic
-  && SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT)
-    DotUnroller<SizeAtCompileTime-1,
-                SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT ? SizeAtCompileTime : Dynamic,
+  && SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT)
+    ei_dot_unroller<SizeAtCompileTime-1,
+                SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT ? SizeAtCompileTime : Dynamic,
                 Derived, MatrixBase<OtherDerived> >
       ::run(*static_cast<const Derived*>(this), other, res);
   else
@@ -123,7 +123,7 @@ typename NumTraits<typename ei_traits<Derived>::Scalar>::Real MatrixBase<Derived
   * \sa norm()
   */
 template<typename Derived>
-const CwiseUnaryOp<ScalarMultipleOp<typename ei_traits<Derived>::Scalar>, Derived>
+const CwiseUnaryOp<ei_scalar_multiple_op<typename ei_traits<Derived>::Scalar>, Derived>
 MatrixBase<Derived>::normalized() const
 {
   return (*this) / norm();
diff --git a/Eigen/src/Core/Eval.h b/Eigen/src/Core/Eval.h
index ece372a04..c841a2887 100644
--- a/Eigen/src/Core/Eval.h
+++ b/Eigen/src/Core/Eval.h
@@ -56,7 +56,7 @@ struct ei_traits<Eval<ExpressionType> >
   };
 };
 
-template<typename ExpressionType> class Eval : NoOperatorEquals,
+template<typename ExpressionType> class Eval : ei_no_assignment_operator,
   public Matrix< typename ExpressionType::Scalar,
                  ExpressionType::RowsAtCompileTime,
                  ExpressionType::ColsAtCompileTime,
@@ -81,7 +81,7 @@ template<typename ExpressionType> class Eval : NoOperatorEquals,
                    ExpressionType::MaxRowsAtCompileTime,
                    ExpressionType::MaxColsAtCompileTime> MatrixType;
 
-    _EIGEN_BASIC_PUBLIC_INTERFACE(Eval, MatrixType)
+    _EIGEN_GENERIC_PUBLIC_INTERFACE(Eval, MatrixType)
 
     explicit Eval(const ExpressionType& expr) : MatrixType(expr) {}
 };
diff --git a/Eigen/src/Core/EvalOMP.h b/Eigen/src/Core/EvalOMP.h
index 929e4515a..6c1f9a89f 100644
--- a/Eigen/src/Core/EvalOMP.h
+++ b/Eigen/src/Core/EvalOMP.h
@@ -51,7 +51,7 @@ struct ei_traits<EvalOMP<ExpressionType> >
   };
 };
 
-template<typename ExpressionType> class EvalOMP : NoOperatorEquals,
+template<typename ExpressionType> class EvalOMP : ei_no_assignment_operator,
   public Matrix< typename ExpressionType::Scalar,
                  ExpressionType::RowsAtCompileTime,
                  ExpressionType::ColsAtCompileTime,
@@ -72,7 +72,7 @@ template<typename ExpressionType> class EvalOMP : NoOperatorEquals,
                    ExpressionType::MaxRowsAtCompileTime,
                    ExpressionType::MaxColsAtCompileTime> MatrixType;
 
-    _EIGEN_BASIC_PUBLIC_INTERFACE(EvalOMP, MatrixType)
+    _EIGEN_GENERIC_PUBLIC_INTERFACE(EvalOMP, MatrixType)
 
     #ifdef _OPENMP
     explicit EvalOMP(const ExpressionType& other)
diff --git a/Eigen/src/Core/ForwardDeclarations.h b/Eigen/src/Core/ForwardDeclarations.h
index a43a34745..3459eab5b 100644
--- a/Eigen/src/Core/ForwardDeclarations.h
+++ b/Eigen/src/Core/ForwardDeclarations.h
@@ -46,13 +46,15 @@ template<typename MatrixType> class Map;
 template<typename Derived> class Eval;
 template<typename Derived> class EvalOMP;
 
-struct ScalarProductOp;
-struct ScalarQuotientOp;
-struct ScalarOppositeOp;
-struct ScalarConjugateOp;
-struct ScalarAbsOp;
-template<typename NewType> struct ScalarCastOp;
-template<typename Scalar>  struct ScalarMultipleOp;
+struct ei_scalar_sum_op;
+struct ei_scalar_difference_op;
+struct ei_scalar_product_op;
+struct ei_scalar_quotient_op;
+struct ei_scalar_opposite_op;
+struct ei_scalar_conjugate_op;
+struct ei_scalar_abs_op;
+template<typename NewType> struct ei_scalar_cast_op;
+template<typename Scalar>  struct ei_scalar_multiple_op;
 
 template<typename T> struct Reference
 {
diff --git a/Eigen/src/Core/Identity.h b/Eigen/src/Core/Identity.h
index 5dd3ec609..2598402b2 100644
--- a/Eigen/src/Core/Identity.h
+++ b/Eigen/src/Core/Identity.h
@@ -43,12 +43,12 @@ struct ei_traits<Identity<MatrixType> >
   };
 };
 
-template<typename MatrixType> class Identity : NoOperatorEquals,
+template<typename MatrixType> class Identity : ei_no_assignment_operator,
   public MatrixBase<Identity<MatrixType> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Identity)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Identity)
 
     Identity(int rows, int cols) : m_rows(rows), m_cols(cols)
     {
@@ -70,8 +70,8 @@ template<typename MatrixType> class Identity : NoOperatorEquals,
     }
 
   protected:
-    const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
-    const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
+    const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
+    const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
 };
 
 /** \returns an expression of the identity matrix (not necessarily square).
diff --git a/Eigen/src/Core/Map.h b/Eigen/src/Core/Map.h
index e1b71952a..ece50087c 100644
--- a/Eigen/src/Core/Map.h
+++ b/Eigen/src/Core/Map.h
@@ -55,7 +55,7 @@ template<typename MatrixType> class Map
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Map)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Map)
 
   private:
 
diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h
index ffb960493..112f5f79e 100644
--- a/Eigen/src/Core/Matrix.h
+++ b/Eigen/src/Core/Matrix.h
@@ -91,7 +91,7 @@ class Matrix : public MatrixBase<Matrix<_Scalar, _Rows, _Cols,
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Matrix)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Matrix)
 
     enum { StorageOrder = _StorageOrder };
 
@@ -102,7 +102,7 @@ class Matrix : public MatrixBase<Matrix<_Scalar, _Rows, _Cols,
 
   private:
 
-    MatrixStorage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime> m_storage;
+    ei_matrix_storage<Scalar, MaxSizeAtCompileTime, RowsAtCompileTime, ColsAtCompileTime> m_storage;
 
     AsArg _asArg() const { return AsArg(*this); }
     int _rows() const { return m_storage.rows(); }
diff --git a/Eigen/src/Core/MatrixBase.h b/Eigen/src/Core/MatrixBase.h
index 18ffdd00f..f89d861ea 100644
--- a/Eigen/src/Core/MatrixBase.h
+++ b/Eigen/src/Core/MatrixBase.h
@@ -230,17 +230,17 @@ template<typename Derived> class MatrixBase
     /// \name matrix transformation
     //@{
     template<typename NewType>
-    const CwiseUnaryOp<ScalarCastOp<NewType>, Derived> cast() const;
+    const CwiseUnaryOp<ei_scalar_cast_op<NewType>, Derived> cast() const;
 
     const DiagonalMatrix<Derived> asDiagonal() const;
 
     Transpose<Derived> transpose();
     const Transpose<Derived> transpose() const;
 
-    const CwiseUnaryOp<ScalarConjugateOp, Derived> conjugate() const;
-    const Transpose<CwiseUnaryOp<ScalarConjugateOp, Derived> > adjoint() const;
+    const CwiseUnaryOp<ei_scalar_conjugate_op, Derived> conjugate() const;
+    const Transpose<CwiseUnaryOp<ei_scalar_conjugate_op, Derived> > adjoint() const;
 
-    const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived> normalized() const;
+    const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> normalized() const;
     //@}
 
     // FIXME not sure about the following name
@@ -295,7 +295,7 @@ template<typename Derived> class MatrixBase
 
     /// \name arithemetic operators
     //@{
-    const CwiseUnaryOp<ScalarOppositeOp,Derived> operator-() const;
+    const CwiseUnaryOp<ei_scalar_opposite_op,Derived> operator-() const;
 
     template<typename OtherDerived>
     Derived& operator+=(const MatrixBase<OtherDerived>& other);
@@ -307,10 +307,10 @@ template<typename Derived> class MatrixBase
     Derived& operator*=(const Scalar& other);
     Derived& operator/=(const Scalar& other);
 
-    const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived> operator*(const Scalar& scalar) const;
-    const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived> operator/(const Scalar& scalar) const;
+    const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> operator*(const Scalar& scalar) const;
+    const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived> operator/(const Scalar& scalar) const;
 
-    friend const CwiseUnaryOp<ScalarMultipleOp<Scalar>, Derived>
+    friend const CwiseUnaryOp<ei_scalar_multiple_op<Scalar>, Derived>
     operator*(const Scalar& scalar, const MatrixBase& matrix)
     { return matrix*scalar; }
 
@@ -318,14 +318,14 @@ template<typename Derived> class MatrixBase
     const Product<Derived, OtherDerived>
     lazyProduct(const MatrixBase<OtherDerived>& other) const EIGEN_ALWAYS_INLINE;
 
-    const CwiseUnaryOp<ScalarAbsOp,Derived> cwiseAbs() const;
+    const CwiseUnaryOp<ei_scalar_abs_op,Derived> cwiseAbs() const;
 
     template<typename OtherDerived>
-    const CwiseBinaryOp<ScalarProductOp, Derived, OtherDerived>
+    const CwiseBinaryOp<ei_scalar_product_op, Derived, OtherDerived>
     cwiseProduct(const MatrixBase<OtherDerived> &other) const;
 
     template<typename OtherDerived>
-    const CwiseBinaryOp<ScalarQuotientOp, Derived, OtherDerived>
+    const CwiseBinaryOp<ei_scalar_quotient_op, Derived, OtherDerived>
     cwiseQuotient(const MatrixBase<OtherDerived> &other) const;
     //@}
 
diff --git a/Eigen/src/Core/MatrixRef.h b/Eigen/src/Core/MatrixRef.h
index 0d0f13f1c..2a5a1a514 100644
--- a/Eigen/src/Core/MatrixRef.h
+++ b/Eigen/src/Core/MatrixRef.h
@@ -42,7 +42,7 @@ template<typename MatrixType> class MatrixRef
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(MatrixRef)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(MatrixRef)
 
     MatrixRef(const MatrixType& matrix) : m_matrix(matrix) {}
     ~MatrixRef() {}
diff --git a/Eigen/src/Core/MatrixStorage.h b/Eigen/src/Core/MatrixStorage.h
index c8cb8b4eb..4bc0423f2 100644
--- a/Eigen/src/Core/MatrixStorage.h
+++ b/Eigen/src/Core/MatrixStorage.h
@@ -26,8 +26,7 @@
 #ifndef EIGEN_MATRIXSTORAGE_H
 #define EIGEN_MATRIXSTORAGE_H
 
-
-/** \class MatrixStorage
+/** \class ei_matrix_storage
   *
   * \brief Stores the data of a matrix
   *
@@ -38,15 +37,15 @@
   *
   * \sa Matrix
   */
-template<typename T, int Size, int _Rows, int _Cols> class MatrixStorage;
+template<typename T, int Size, int _Rows, int _Cols> class ei_matrix_storage;
 
 // purely fixed-size matrix.
-template<typename T, int Size, int _Rows, int _Cols> class MatrixStorage
+template<typename T, int Size, int _Rows, int _Cols> class ei_matrix_storage
 {
     T m_data[Size];
   public:
-    MatrixStorage() {}
-    MatrixStorage(int,int,int) {}
+    ei_matrix_storage() {}
+    ei_matrix_storage(int,int,int) {}
     static int rows(void) {return _Rows;}
     static int cols(void) {return _Cols;}
     void resize(int,int,int) {}
@@ -55,14 +54,14 @@ template<typename T, int Size, int _Rows, int _Cols> class MatrixStorage
 };
 
 // dynamic-size matrix with fixed-size storage
-template<typename T, int Size> class MatrixStorage<T, Size, Dynamic, Dynamic>
+template<typename T, int Size> class ei_matrix_storage<T, Size, Dynamic, Dynamic>
 {
     T m_data[Size];
     int m_rows;
     int m_cols;
   public:
-    MatrixStorage(int, int rows, int cols) : m_rows(rows), m_cols(cols) {}
-    ~MatrixStorage() {}
+    ei_matrix_storage(int, int rows, int cols) : m_rows(rows), m_cols(cols) {}
+    ~ei_matrix_storage() {}
     int rows(void) const {return m_rows;}
     int cols(void) const {return m_cols;}
     void resize(int, int rows, int cols)
@@ -75,13 +74,13 @@ template<typename T, int Size> class MatrixStorage<T, Size, Dynamic, Dynamic>
 };
 
 // dynamic-size matrix with fixed-size storage and fixed width
-template<typename T, int Size, int _Cols> class MatrixStorage<T, Size, Dynamic, _Cols>
+template<typename T, int Size, int _Cols> class ei_matrix_storage<T, Size, Dynamic, _Cols>
 {
     T m_data[Size];
     int m_rows;
   public:
-    MatrixStorage(int, int rows, int) : m_rows(rows) {}
-    ~MatrixStorage() {}
+    ei_matrix_storage(int, int rows, int) : m_rows(rows) {}
+    ~ei_matrix_storage() {}
     int rows(void) const {return m_rows;}
     int cols(void) const {return _Cols;}
     void resize(int size, int rows, int)
@@ -93,13 +92,13 @@ template<typename T, int Size, int _Cols> class MatrixStorage<T, Size, Dynamic,
 };
 
 // dynamic-size matrix with fixed-size storage and fixed height
-template<typename T, int Size, int _Rows> class MatrixStorage<T, Size, _Rows, Dynamic>
+template<typename T, int Size, int _Rows> class ei_matrix_storage<T, Size, _Rows, Dynamic>
 {
     T m_data[Size];
     int m_cols;
   public:
-    MatrixStorage(int, int, int cols) : m_cols(cols) {}
-    ~MatrixStorage() {}
+    ei_matrix_storage(int, int, int cols) : m_cols(cols) {}
+    ~ei_matrix_storage() {}
     int rows(void) const {return _Rows;}
     int cols(void) const {return m_cols;}
     void resize(int size, int, int cols)
@@ -111,15 +110,15 @@ template<typename T, int Size, int _Rows> class MatrixStorage<T, Size, _Rows, Dy
 };
 
 // purely dynamic matrix.
-template<typename T> class MatrixStorage<T, Dynamic, Dynamic, Dynamic>
+template<typename T> class ei_matrix_storage<T, Dynamic, Dynamic, Dynamic>
 {
     T *m_data;
     int m_rows;
     int m_cols;
   public:
-    MatrixStorage(int size, int rows, int cols)
+    ei_matrix_storage(int size, int rows, int cols)
       : m_data(new T[size]), m_rows(rows), m_cols(cols) {}
-    ~MatrixStorage() { delete[] m_data; }
+    ~ei_matrix_storage() { delete[] m_data; }
     int rows(void) const {return m_rows;}
     int cols(void) const {return m_cols;}
     void resize(int size, int rows, int cols)
@@ -137,13 +136,13 @@ template<typename T> class MatrixStorage<T, Dynamic, Dynamic, Dynamic>
 };
 
 // matrix with dynamic width and fixed height (so that matrix has dynamic size).
-template<typename T, int _Rows> class MatrixStorage<T, Dynamic, _Rows, Dynamic>
+template<typename T, int _Rows> class ei_matrix_storage<T, Dynamic, _Rows, Dynamic>
 {
     T *m_data;
     int m_cols;
   public:
-    MatrixStorage(int size, int, int cols) : m_data(new T[size]), m_cols(cols) {}
-    ~MatrixStorage() { delete[] m_data; }
+    ei_matrix_storage(int size, int, int cols) : m_data(new T[size]), m_cols(cols) {}
+    ~ei_matrix_storage() { delete[] m_data; }
     static int rows(void) {return _Rows;}
     int cols(void) const {return m_cols;}
     void resize(int size, int, int cols)
@@ -160,13 +159,13 @@ template<typename T, int _Rows> class MatrixStorage<T, Dynamic, _Rows, Dynamic>
 };
 
 // matrix with dynamic height and fixed width (so that matrix has dynamic size).
-template<typename T, int _Cols> class MatrixStorage<T, Dynamic, Dynamic, _Cols>
+template<typename T, int _Cols> class ei_matrix_storage<T, Dynamic, Dynamic, _Cols>
 {
     T *m_data;
     int m_rows;
   public:
-    MatrixStorage(int size, int rows, int) : m_data(new T[size]), m_rows(rows) {}
-    ~MatrixStorage() { delete[] m_data; }
+    ei_matrix_storage(int size, int rows, int) : m_data(new T[size]), m_rows(rows) {}
+    ~ei_matrix_storage() { delete[] m_data; }
     int rows(void) const {return m_rows;}
     static int cols(void) {return _Cols;}
     void resize(int size, int rows, int)
diff --git a/Eigen/src/Core/Minor.h b/Eigen/src/Core/Minor.h
index bb957b16b..fbd6224aa 100644
--- a/Eigen/src/Core/Minor.h
+++ b/Eigen/src/Core/Minor.h
@@ -58,7 +58,7 @@ template<typename MatrixType> class Minor
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Minor)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Minor)
 
     typedef typename MatrixType::AsArg MatRef;
 
diff --git a/Eigen/src/Core/Ones.h b/Eigen/src/Core/Ones.h
index 34bc3e8a7..836887c43 100644
--- a/Eigen/src/Core/Ones.h
+++ b/Eigen/src/Core/Ones.h
@@ -44,12 +44,12 @@ struct ei_traits<Ones<MatrixType> >
   };
 };
 
-template<typename MatrixType> class Ones : NoOperatorEquals,
+template<typename MatrixType> class Ones : ei_no_assignment_operator,
   public MatrixBase<Ones<MatrixType> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Ones)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Ones)
 
   private:
 
@@ -72,8 +72,8 @@ template<typename MatrixType> class Ones : NoOperatorEquals,
     }
 
   protected:
-    const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
-    const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
+    const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
+    const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
 };
 
 /** \returns an expression of a matrix where all coefficients equal one.
diff --git a/Eigen/src/Core/OperatorEquals.h b/Eigen/src/Core/OperatorEquals.h
index 42d8ed9ee..020296c2f 100644
--- a/Eigen/src/Core/OperatorEquals.h
+++ b/Eigen/src/Core/OperatorEquals.h
@@ -27,7 +27,7 @@
 #define EIGEN_OPERATOREQUALS_H
 
 template<typename Derived1, typename Derived2, int UnrollCount>
-struct MatrixOperatorEqualsUnroller
+struct ei_matrix_operator_equals_unroller
 {
   enum {
     col = (UnrollCount-1) / Derived1::RowsAtCompileTime,
@@ -36,13 +36,13 @@ struct MatrixOperatorEqualsUnroller
 
   static void run(Derived1 &dst, const Derived2 &src)
   {
-    MatrixOperatorEqualsUnroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
+    ei_matrix_operator_equals_unroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
     dst.coeffRef(row, col) = src.coeff(row, col);
   }
 };
 
 template<typename Derived1, typename Derived2>
-struct MatrixOperatorEqualsUnroller<Derived1, Derived2, 1>
+struct ei_matrix_operator_equals_unroller<Derived1, Derived2, 1>
 {
   static void run(Derived1 &dst, const Derived2 &src)
   {
@@ -52,38 +52,38 @@ struct MatrixOperatorEqualsUnroller<Derived1, Derived2, 1>
 
 // prevent buggy user code from causing an infinite recursion
 template<typename Derived1, typename Derived2>
-struct MatrixOperatorEqualsUnroller<Derived1, Derived2, 0>
+struct ei_matrix_operator_equals_unroller<Derived1, Derived2, 0>
 {
   static void run(Derived1 &, const Derived2 &) {}
 };
 
 template<typename Derived1, typename Derived2>
-struct MatrixOperatorEqualsUnroller<Derived1, Derived2, Dynamic>
+struct ei_matrix_operator_equals_unroller<Derived1, Derived2, Dynamic>
 {
   static void run(Derived1 &, const Derived2 &) {}
 };
 
 template<typename Derived1, typename Derived2, int UnrollCount>
-struct VectorOperatorEqualsUnroller
+struct ei_vector_operator_equals_unroller
 {
   enum { index = UnrollCount - 1 };
 
   static void run(Derived1 &dst, const Derived2 &src)
   {
-    VectorOperatorEqualsUnroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
+    ei_vector_operator_equals_unroller<Derived1, Derived2, UnrollCount-1>::run(dst, src);
     dst.coeffRef(index) = src.coeff(index);
   }
 };
 
 // prevent buggy user code from causing an infinite recursion
 template<typename Derived1, typename Derived2>
-struct VectorOperatorEqualsUnroller<Derived1, Derived2, 0>
+struct ei_vector_operator_equals_unroller<Derived1, Derived2, 0>
 {
   static void run(Derived1 &, const Derived2 &) {}
 };
 
 template<typename Derived1, typename Derived2>
-struct VectorOperatorEqualsUnroller<Derived1, Derived2, 1>
+struct ei_vector_operator_equals_unroller<Derived1, Derived2, 1>
 {
   static void run(Derived1 &dst, const Derived2 &src)
   {
@@ -92,7 +92,7 @@ struct VectorOperatorEqualsUnroller<Derived1, Derived2, 1>
 };
 
 template<typename Derived1, typename Derived2>
-struct VectorOperatorEqualsUnroller<Derived1, Derived2, Dynamic>
+struct ei_vector_operator_equals_unroller<Derived1, Derived2, Dynamic>
 {
   static void run(Derived1 &, const Derived2 &) {}
 };
@@ -108,10 +108,10 @@ Derived& MatrixBase<Derived>
     assert(size() == other.size());
     if(EIGEN_UNROLLED_LOOPS
     && SizeAtCompileTime != Dynamic
-    && SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL)
-      VectorOperatorEqualsUnroller
+    && SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT)
+      ei_vector_operator_equals_unroller
         <Derived, OtherDerived,
-          SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL ? SizeAtCompileTime : Dynamic>::run
+          SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT ? SizeAtCompileTime : Dynamic>::run
           (*static_cast<Derived*>(this), *static_cast<const OtherDerived*>(&other));
     else
       for(int i = 0; i < size(); i++)
@@ -123,11 +123,11 @@ Derived& MatrixBase<Derived>
     assert(rows() == other.rows() && cols() == other.cols());
     if(EIGEN_UNROLLED_LOOPS
     && SizeAtCompileTime != Dynamic
-    && SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL)
+    && SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT)
     {
-      MatrixOperatorEqualsUnroller
+      ei_matrix_operator_equals_unroller
         <Derived, OtherDerived,
-          SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT_OPEQUAL ? SizeAtCompileTime : Dynamic>::run
+          SizeAtCompileTime <= EIGEN_UNROLLING_LIMIT ? SizeAtCompileTime : Dynamic>::run
           (*static_cast<Derived*>(this), *static_cast<const OtherDerived*>(&other));
     }
     else
diff --git a/Eigen/src/Core/Product.h b/Eigen/src/Core/Product.h
index f0f412025..68f6da97f 100644
--- a/Eigen/src/Core/Product.h
+++ b/Eigen/src/Core/Product.h
@@ -26,18 +26,18 @@
 #define EIGEN_PRODUCT_H
 
 template<int Index, int Size, typename Lhs, typename Rhs>
-struct ProductUnroller
+struct ei_product_unroller
 {
   static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
                   typename Lhs::Scalar &res)
   {
-    ProductUnroller<Index-1, Size, Lhs, Rhs>::run(row, col, lhs, rhs, res);
+    ei_product_unroller<Index-1, Size, Lhs, Rhs>::run(row, col, lhs, rhs, res);
     res += lhs.coeff(row, Index) * rhs.coeff(Index, col);
   }
 };
 
 template<int Size, typename Lhs, typename Rhs>
-struct ProductUnroller<0, Size, Lhs, Rhs>
+struct ei_product_unroller<0, Size, Lhs, Rhs>
 {
   static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
                   typename Lhs::Scalar &res)
@@ -47,14 +47,14 @@ struct ProductUnroller<0, Size, Lhs, Rhs>
 };
 
 template<int Index, typename Lhs, typename Rhs>
-struct ProductUnroller<Index, Dynamic, Lhs, Rhs>
+struct ei_product_unroller<Index, Dynamic, Lhs, Rhs>
 {
   static void run(int, int, const Lhs&, const Rhs&, typename Lhs::Scalar&) {}
 };
 
 // prevent buggy user code from causing an infinite recursion
 template<int Index, typename Lhs, typename Rhs>
-struct ProductUnroller<Index, 0, Lhs, Rhs>
+struct ei_product_unroller<Index, 0, Lhs, Rhs>
 {
   static void run(int, int, const Lhs&, const Rhs&, typename Lhs::Scalar&) {}
 };
@@ -84,12 +84,12 @@ struct ei_traits<Product<Lhs, Rhs> >
   };
 };
 
-template<typename Lhs, typename Rhs> class Product : NoOperatorEquals,
+template<typename Lhs, typename Rhs> class Product : ei_no_assignment_operator,
   public MatrixBase<Product<Lhs, Rhs> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Product)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Product)
 
     typedef typename Lhs::AsArg LhsRef;
     typedef typename Rhs::AsArg RhsRef;
@@ -111,9 +111,9 @@ template<typename Lhs, typename Rhs> class Product : NoOperatorEquals,
       Scalar res;
       if(EIGEN_UNROLLED_LOOPS
       && Lhs::ColsAtCompileTime != Dynamic
-      && Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT)
-        ProductUnroller<Lhs::ColsAtCompileTime-1,
-                        Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT ? Lhs::ColsAtCompileTime : Dynamic,
+      && Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT)
+        ei_product_unroller<Lhs::ColsAtCompileTime-1,
+                        Lhs::ColsAtCompileTime <= EIGEN_UNROLLING_LIMIT ? Lhs::ColsAtCompileTime : Dynamic,
                         LhsRef, RhsRef>
           ::run(row, col, m_lhs, m_rhs, res);
       else
diff --git a/Eigen/src/Core/Random.h b/Eigen/src/Core/Random.h
index 1c2154b43..e560a708d 100644
--- a/Eigen/src/Core/Random.h
+++ b/Eigen/src/Core/Random.h
@@ -44,12 +44,12 @@ struct ei_traits<Random<MatrixType> >
   };
 };
 
-template<typename MatrixType> class Random : NoOperatorEquals,
+template<typename MatrixType> class Random : ei_no_assignment_operator,
   public MatrixBase<Random<MatrixType> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Random)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Random)
 
     const Random& _asArg() const { return *this; }
     int _rows() const { return m_rows.value(); }
@@ -70,8 +70,8 @@ template<typename MatrixType> class Random : NoOperatorEquals,
     }
 
   protected:
-    const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
-    const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
+    const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
+    const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
 };
 
 /** \returns a random matrix (not an expression, the matrix is immediately evaluated).
diff --git a/Eigen/src/Core/Trace.h b/Eigen/src/Core/Trace.h
index c106f0a9d..dcb317de5 100644
--- a/Eigen/src/Core/Trace.h
+++ b/Eigen/src/Core/Trace.h
@@ -25,16 +25,16 @@
 #ifndef EIGEN_TRACE_H
 #define EIGEN_TRACE_H
 
-template<int Index, int Rows, typename Derived> struct TraceUnroller
+template<int Index, int Rows, typename Derived> struct ei_trace_unroller
 {
   static void run(const Derived &mat, typename Derived::Scalar &trace)
   {
-    TraceUnroller<Index-1, Rows, Derived>::run(mat, trace);
+    ei_trace_unroller<Index-1, Rows, Derived>::run(mat, trace);
     trace += mat.coeff(Index, Index);
   }
 };
 
-template<int Rows, typename Derived> struct TraceUnroller<0, Rows, Derived>
+template<int Rows, typename Derived> struct ei_trace_unroller<0, Rows, Derived>
 {
   static void run(const Derived &mat, typename Derived::Scalar &trace)
   {
@@ -42,13 +42,13 @@ template<int Rows, typename Derived> struct TraceUnroller<0, Rows, Derived>
   }
 };
 
-template<int Index, typename Derived> struct TraceUnroller<Index, Dynamic, Derived>
+template<int Index, typename Derived> struct ei_trace_unroller<Index, Dynamic, Derived>
 {
   static void run(const Derived&, typename Derived::Scalar&) {}
 };
 
 // prevent buggy user code from causing an infinite recursion
-template<int Index, typename Derived> struct TraceUnroller<Index, 0, Derived>
+template<int Index, typename Derived> struct ei_trace_unroller<Index, 0, Derived>
 {
   static void run(const Derived&, typename Derived::Scalar&) {}
 };
@@ -64,9 +64,9 @@ MatrixBase<Derived>::trace() const
   Scalar res;
   if(EIGEN_UNROLLED_LOOPS
   && RowsAtCompileTime != Dynamic
-  && RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT)
-    TraceUnroller<RowsAtCompileTime-1,
-      RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT_PRODUCT ? RowsAtCompileTime : Dynamic, Derived>
+  && RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT)
+    ei_trace_unroller<RowsAtCompileTime-1,
+      RowsAtCompileTime <= EIGEN_UNROLLING_LIMIT ? RowsAtCompileTime : Dynamic, Derived>
       ::run(*static_cast<const Derived*>(this), res);
   else
   {
diff --git a/Eigen/src/Core/Transpose.h b/Eigen/src/Core/Transpose.h
index 8f802818f..d6613989e 100644
--- a/Eigen/src/Core/Transpose.h
+++ b/Eigen/src/Core/Transpose.h
@@ -54,7 +54,7 @@ template<typename MatrixType> class Transpose
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Transpose)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Transpose)
 
     typedef typename MatrixType::AsArg MatRef;
 
@@ -108,9 +108,9 @@ MatrixBase<Derived>::transpose() const
   * Example: \include MatrixBase_adjoint.cpp
   * Output: \verbinclude MatrixBase_adjoint.out
   *
-  * \sa transpose(), conjugate(), class Transpose, class ScalarConjugateOp */
+  * \sa transpose(), conjugate(), class Transpose, class ei_scalar_conjugate_op */
 template<typename Derived>
-const Transpose<CwiseUnaryOp<ScalarConjugateOp, Derived> >
+const Transpose<CwiseUnaryOp<ei_scalar_conjugate_op, Derived> >
 MatrixBase<Derived>::adjoint() const
 {
   return conjugate().transpose();
diff --git a/Eigen/src/Core/Util.h b/Eigen/src/Core/Util.h
index 5b93c3f78..3c970d6e8 100644
--- a/Eigen/src/Core/Util.h
+++ b/Eigen/src/Core/Util.h
@@ -31,18 +31,9 @@
 #define EIGEN_UNROLLED_LOOPS (true)
 #endif
 
-/** Defines the maximal loop size (i.e., the matrix size NxM) to enable
-  * meta unrolling of operator=.
-  */
-#ifndef EIGEN_UNROLLING_LIMIT_OPEQUAL
-#define EIGEN_UNROLLING_LIMIT_OPEQUAL 25
-#endif
-
-/** Defines the maximal loop size to enable meta unrolling
-  * of the matrix product, dot product and trace.
-  */
-#ifndef EIGEN_UNROLLING_LIMIT_PRODUCT
-#define EIGEN_UNROLLING_LIMIT_PRODUCT 16
+/** Defines the maximal loop size to enable meta unrolling of loops */
+#ifndef EIGEN_UNROLLING_LIMIT
+#define EIGEN_UNROLLING_LIMIT 16
 #endif
 
 #ifdef EIGEN_DEFAULT_TO_ROW_MAJOR
@@ -105,20 +96,20 @@ EIGEN_INHERIT_ASSIGNMENT_OPERATOR(Derived, -=) \
 EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, *=) \
 EIGEN_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, /=)
 
-#define _EIGEN_BASIC_PUBLIC_INTERFACE(Derived, BaseClass) \
-friend class MatrixBase<Derived>; \
+#define _EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, BaseClass) \
 typedef BaseClass Base; \
 typedef typename ei_traits<Derived>::Scalar Scalar; \
-enum { RowsAtCompileTime = ei_traits<Derived>::RowsAtCompileTime, \
-       ColsAtCompileTime = ei_traits<Derived>::ColsAtCompileTime, \
-       MaxRowsAtCompileTime = ei_traits<Derived>::MaxRowsAtCompileTime, \
-       MaxColsAtCompileTime = ei_traits<Derived>::MaxColsAtCompileTime }; \
+using Base::RowsAtCompileTime; \
+using Base::ColsAtCompileTime; \
+using Base::MaxRowsAtCompileTime; \
+using Base::MaxColsAtCompileTime; \
 using Base::SizeAtCompileTime; \
 using Base::MaxSizeAtCompileTime; \
 using Base::IsVectorAtCompileTime;
 
-#define EIGEN_BASIC_PUBLIC_INTERFACE(Derived) \
-_EIGEN_BASIC_PUBLIC_INTERFACE(Derived, MatrixBase<Derived>)
+#define EIGEN_GENERIC_PUBLIC_INTERFACE(Derived) \
+_EIGEN_GENERIC_PUBLIC_INTERFACE(Derived, MatrixBase<Derived>) \
+friend class MatrixBase<Derived>;
 
 #define EIGEN_ENUM_MIN(a,b) (((int)a <= (int)b) ? (int)a : (int)b)
 
@@ -130,34 +121,34 @@ enum CornerType { TopLeft, TopRight, BottomLeft, BottomRight };
 
 // just a workaround because GCC seems to not really like empty structs
 #ifdef __GNUG__
-  struct EiEmptyStruct{char _ei_dummy_;};
-  #define EIGEN_EMPTY_STRUCT : Eigen::EiEmptyStruct
+  struct ei_empty_struct{char _ei_dummy_;};
+  #define EIGEN_EMPTY_STRUCT : Eigen::ei_empty_struct
 #else
   #define EIGEN_EMPTY_STRUCT
 #endif
 
-//classes inheriting NoOperatorEquals don't generate a default operator=.
-class NoOperatorEquals
+//classes inheriting ei_no_assignment_operator don't generate a default operator=.
+class ei_no_assignment_operator
 {
   private:
-    NoOperatorEquals& operator=(const NoOperatorEquals&);
+    ei_no_assignment_operator& operator=(const ei_no_assignment_operator&);
 };
 
-template<int Value> class IntAtRunTimeIfDynamic EIGEN_EMPTY_STRUCT
+template<int Value> class ei_int_if_dynamic EIGEN_EMPTY_STRUCT
 {
   public:
-    IntAtRunTimeIfDynamic() {}
-    explicit IntAtRunTimeIfDynamic(int) {}
+    ei_int_if_dynamic() {}
+    explicit ei_int_if_dynamic(int) {}
     static int value() { return Value; }
     void setValue(int) {}
 };
 
-template<> class IntAtRunTimeIfDynamic<Dynamic>
+template<> class ei_int_if_dynamic<Dynamic>
 {
     int m_value;
-    IntAtRunTimeIfDynamic() {}
+    ei_int_if_dynamic() {}
   public:
-    explicit IntAtRunTimeIfDynamic(int value) : m_value(value) {}
+    explicit ei_int_if_dynamic(int value) : m_value(value) {}
     int value() const { return m_value; }
     void setValue(int value) { m_value = value; }
 };
diff --git a/Eigen/src/Core/Zero.h b/Eigen/src/Core/Zero.h
index 7848bb048..3c9fbf533 100644
--- a/Eigen/src/Core/Zero.h
+++ b/Eigen/src/Core/Zero.h
@@ -44,12 +44,12 @@ struct ei_traits<Zero<MatrixType> >
   };
 };
 
-template<typename MatrixType> class Zero : NoOperatorEquals,
+template<typename MatrixType> class Zero : ei_no_assignment_operator,
   public MatrixBase<Zero<MatrixType> >
 {
   public:
 
-    EIGEN_BASIC_PUBLIC_INTERFACE(Zero)
+    EIGEN_GENERIC_PUBLIC_INTERFACE(Zero)
 
   private:
 
@@ -73,8 +73,8 @@ template<typename MatrixType> class Zero : NoOperatorEquals,
     }
 
   protected:
-    const IntAtRunTimeIfDynamic<RowsAtCompileTime> m_rows;
-    const IntAtRunTimeIfDynamic<ColsAtCompileTime> m_cols;
+    const ei_int_if_dynamic<RowsAtCompileTime> m_rows;
+    const ei_int_if_dynamic<ColsAtCompileTime> m_cols;
 };
 
 /** \returns an expression of a zero matrix.
diff --git a/bench/bench_unrolling b/bench/bench_unrolling
index 4af791412..7934031a8 100755
--- a/bench/bench_unrolling
+++ b/bench/bench_unrolling
@@ -5,7 +5,7 @@
 
 for ((i=1; i<16; ++i)); do
     echo "Matrix size: $i x $i :"
-    $CXX -O3 -I.. -DNDEBUG  benchmark.cpp -DMATSIZE=$i -DEIGEN_UNROLLING_LIMIT_OPEQUAL=1024 -DEIGEN_UNROLLING_LIMIT_PRODUCT=25 -o benchmark && time ./benchmark >/dev/null
+    $CXX -O3 -I.. -DNDEBUG  benchmark.cpp -DMATSIZE=$i -DEIGEN_UNROLLING_LIMIT=1024 -DEIGEN_UNROLLING_LIMIT=25 -o benchmark && time ./benchmark >/dev/null
     $CXX -O3 -I.. -DNDEBUG -finline-limit=10000 benchmark.cpp -DMATSIZE=$i -DEIGEN_DONT_USE_UNROLLED_LOOPS=1 -o benchmark && time ./benchmark >/dev/null
     echo " "
 done
diff --git a/doc/examples/class_Cast.cpp b/doc/examples/class_Cast.cpp
index 68b8d2437..7e752be1b 100644
--- a/doc/examples/class_Cast.cpp
+++ b/doc/examples/class_Cast.cpp
@@ -4,14 +4,14 @@ using namespace std;
 
 template<typename Derived>
 const Eigen::CwiseUnaryOp<
-  Eigen::ScalarCastOp<
-    typename Eigen::NumTraits<typename Derived::Scalar>::FloatingPoint
+  Eigen::ei_scalar_cast_op<
+    typename Eigen::ei_traits<typename Derived::Scalar>::FloatingPoint
   >, Derived
 >
 castToFloatingPoint(const MatrixBase<Derived>& m)
 {
   return m.template cast<
-    typename Eigen::NumTraits<
+    typename Eigen::ei_traits<
       typename Derived::Scalar
     >::FloatingPoint
   >();
diff --git a/test/submatrices.cpp b/test/submatrices.cpp
index cba88bda6..640a0fba6 100644
--- a/test/submatrices.cpp
+++ b/test/submatrices.cpp
@@ -28,7 +28,7 @@ namespace Eigen {
 
 // check minor separately in order to avoid the possible creation of a zero-sized
 // array. Comes from a compilation error with gcc-3.4 or gcc-4 with -ansi -pedantic.
-// Another solution would be to declare the array like this: T m_data[Size==0?1:Size]; in MatrixStorage
+// Another solution would be to declare the array like this: T m_data[Size==0?1:Size]; in ei_matrix_storage
 // but this is probably not bad to raise such an error at compile time...
 template<typename Scalar, int _Rows, int _Cols> struct CheckMinor
 {
-- 
cgit v1.2.3