diff --git a/CMakeLists.txt b/CMakeLists.txt
index 180453180..e499bdf92 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,4 +1,4 @@
-project(Eigen)
+project(gen)
 
 OPTION(BUILD_TESTS "Build tests"  OFF)
 OPTION(BUILD_EXAMPLES "Build examples"  OFF)
diff --git a/doc/example.cpp b/doc/example.cpp
index 75d47f988..ca10d077a 100644
--- a/doc/example.cpp
+++ b/doc/example.cpp
@@ -1,23 +1,25 @@
 #include "../src/Core.h"
 
+USING_EIGEN_DATA_TYPES
+
 using namespace std;
 
 template<typename Scalar, typename Derived>
-void foo(const EiObject<Scalar, Derived>& m)
+void foo(const Eigen::Object<Scalar, Derived>& m)
 {
 	cout << "Here's m:" << endl << m << endl;
 }
 
 template<typename Scalar, typename Derived>
-EiScalarProduct<Derived>
-twice(const EiObject<Scalar, Derived>& m)
+Eigen::ScalarProduct<Derived>
+twice(const Eigen::Object<Scalar, Derived>& m)
 {
 	return 2 * m;
 }
 
 int main(int, char**)
 {
-	EiMatrix2d m;
+	Matrix2d m;
 	m(0,0)= 1;
 	m(1,0)= 2;
 	m(0,1)= 3;
diff --git a/doc/tutorial.cpp b/doc/tutorial.cpp
index ab145bf3f..4400bd2d1 100644
--- a/doc/tutorial.cpp
+++ b/doc/tutorial.cpp
@@ -1,10 +1,12 @@
 #include "../src/Core.h"
 
+USING_EIGEN_DATA_TYPES
+
 using namespace std;
 
 int main(int, char **)
 {
-  EiMatrix<double,2,2> m; // 2x2 fixed-size matrix with uninitialized entries
+  Matrix<double,2,2> m; // 2x2 fixed-size matrix with uninitialized entries
   m(0,0) = 1;
   m(0,1) = 2;
   m(1,0) = 3;
@@ -12,7 +14,7 @@ int main(int, char **)
 
   cout << "Here is a 2x2 matrix m:" << endl << m << endl;
   cout << "Let us now build a 4x4 matrix m2 by assembling together four 2x2 blocks." << endl;
-  EiMatrixXd m2(4,4); // dynamic matrix with initial size 4x4 and uninitialized entries
+  MatrixXd m2(4,4); // dynamic matrix with initial size 4x4 and uninitialized entries
   // notice how we are mixing fixed-size and dynamic-size types.
   
   cout << "In the top-left block, we put the matrix m shown above." << endl;
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 12c48c4a4..78a05eec6 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,4 @@
-FILE(GLOB Eigen_SRCS "*.h")
+FILE(GLOB gen_SRCS "*.h")
 
 SET(INCLUDE_INSTALL_DIR
     "${CMAKE_INSTALL_PREFIX}/include/eigen2"
@@ -7,7 +7,7 @@ SET(INCLUDE_INSTALL_DIR
     FORCE)
 
 INSTALL(FILES 
-  ${Eigen_SRCS}
+  ${gen_SRCS}
   DESTINATION ${INCLUDE_INSTALL_DIR}
   )
 
diff --git a/src/Core.h b/src/Core.h
index 658f7fe08..2fd9423dd 100644
--- a/src/Core.h
+++ b/src/Core.h
@@ -1,3 +1,10 @@
+
+#include <iostream>
+#include <complex>
+#include <cassert>
+
+namespace Eigen {
+
 #include "Core/Util.h"
 #include "Core/Numeric.h"
 #include "Core/Object.h"
@@ -14,3 +21,5 @@
 #include "Core/Trace.h"
 #include "Core/Dot.h"
 #include "Core/Random.h"
+
+} // namespace Eigen
diff --git a/src/Core/Block.h b/src/Core/Block.h
index 90bb9ac8a..1ddd86540 100644
--- a/src/Core/Block.h
+++ b/src/Core/Block.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,18 +26,18 @@
 #ifndef EI_BLOCK_H
 #define EI_BLOCK_H
 
-template<typename MatrixType> class EiBlock
-  : public EiObject<typename MatrixType::Scalar, EiBlock<MatrixType> >
+template<typename MatrixType> class Block
+  : public Object<typename MatrixType::Scalar, Block<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Ref MatRef;
-    friend class EiObject<Scalar, EiBlock<MatrixType> >;
+    friend class Object<Scalar, Block<MatrixType> >;
     
-    static const int RowsAtCompileTime = EiDynamic,
-                     ColsAtCompileTime = EiDynamic;
+    static const int RowsAtCompileTime = Dynamic,
+                     ColsAtCompileTime = Dynamic;
 
-    EiBlock(const MatRef& matrix,
+    Block(const MatRef& matrix,
                 int startRow, int endRow,
                 int startCol = 0, int endCol = 0)
       : m_matrix(matrix), m_startRow(startRow), m_endRow(endRow),
@@ -47,15 +47,15 @@ template<typename MatrixType> class EiBlock
           && startCol >= 0 && startCol <= endCol && endCol < matrix.cols());
     }
     
-    EiBlock(const EiBlock& other)
+    Block(const Block& other)
       : m_matrix(other.m_matrix), m_startRow(other.m_startRow), m_endRow(other.m_endRow),
                                   m_startCol(other.m_startCol), m_endCol(other.m_endCol) {}
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiBlock)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Block)
     
   private:
-    EiBlock& _ref() { return *this; }
-    const EiBlock& _constRef() const { return *this; }
+    Block& _ref() { return *this; }
+    const Block& _constRef() const { return *this; }
     int _rows() const { return m_endRow - m_startRow + 1; }
     int _cols() const { return m_endCol - m_startCol + 1; }
     
@@ -75,10 +75,10 @@ template<typename MatrixType> class EiBlock
 };
 
 template<typename Scalar, typename Derived>
-EiBlock<Derived>
-EiObject<Scalar, Derived>::block(int startRow, int endRow, int startCol, int endCol)
+Block<Derived>
+Object<Scalar, Derived>::block(int startRow, int endRow, int startCol, int endCol)
 {
-  return EiBlock<Derived>(static_cast<Derived*>(this)->ref(), startRow, endRow, startCol, endCol);
+  return Block<Derived>(static_cast<Derived*>(this)->ref(), startRow, endRow, startCol, endCol);
 }
 
 #endif // EI_BLOCK_H
diff --git a/src/Core/CMakeLists.txt b/src/Core/CMakeLists.txt
index dc4473416..f5a6743ce 100644
--- a/src/Core/CMakeLists.txt
+++ b/src/Core/CMakeLists.txt
@@ -1,6 +1,6 @@
-FILE(GLOB Eigen_Core_SRCS "*.h")
+FILE(GLOB gen_Core_SRCS "*.h")
 
 INSTALL(FILES 
-  ${Eigen_Core_SRCS}
+  ${gen_Core_SRCS}
   DESTINATION ${INCLUDE_INSTALL_DIR}/Core
   )
diff --git a/src/Core/Column.h b/src/Core/Column.h
index f83028ed0..bc669261a 100644
--- a/src/Core/Column.h
+++ b/src/Core/Column.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,31 +26,31 @@
 #ifndef EI_COLUMN_H
 #define EI_COLUMN_H
 
-template<typename MatrixType> class EiColumn
-  : public EiObject<typename MatrixType::Scalar, EiColumn<MatrixType> >
+template<typename MatrixType> class Column
+  : public Object<typename MatrixType::Scalar, Column<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Ref MatRef;
-    friend class EiObject<Scalar, EiColumn<MatrixType> >;
+    friend class Object<Scalar, Column<MatrixType> >;
     
     static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
                      ColsAtCompileTime = 1;
     
-    EiColumn(const MatRef& matrix, int col)
+    Column(const MatRef& matrix, int col)
       : m_matrix(matrix), m_col(col)
     {
       EI_CHECK_COL_RANGE(matrix, col);
     }
     
-    EiColumn(const EiColumn& other)
+    Column(const Column& other)
       : m_matrix(other.m_matrix), m_col(other.m_col) {}
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiColumn)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Column)
     
   private:
-    EiColumn& _ref() { return *this; }
-    const EiColumn& _constRef() const { return *this; }
+    Column& _ref() { return *this; }
+    const Column& _constRef() const { return *this; }
     int _rows() const { return m_matrix.rows(); }
     int _cols() const { return 1; }
     
@@ -74,10 +74,10 @@ template<typename MatrixType> class EiColumn
 };
 
 template<typename Scalar, typename Derived>
-EiColumn<Derived>
-EiObject<Scalar, Derived>::col(int i)
+Column<Derived>
+Object<Scalar, Derived>::col(int i)
 {
-  return EiColumn<Derived>(static_cast<Derived*>(this)->ref(), i);
+  return Column<Derived>(static_cast<Derived*>(this)->ref(), i);
 }
 
 #endif // EI_COLUMN_H
diff --git a/src/Core/Conjugate.h b/src/Core/Conjugate.h
index 9ca055e92..6431558f4 100644
--- a/src/Core/Conjugate.h
+++ b/src/Core/Conjugate.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,33 +26,33 @@
 #ifndef EI_CONJUGATE_H
 #define EI_CONJUGATE_H
 
-template<typename MatrixType> class EiConjugate
-  : public EiObject<typename MatrixType::Scalar, EiConjugate<MatrixType> >
+template<typename MatrixType> class Conjugate
+  : public Object<typename MatrixType::Scalar, Conjugate<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::ConstRef MatRef;
-    friend class EiObject<Scalar, EiConjugate<MatrixType> >;
+    friend class Object<Scalar, Conjugate<MatrixType> >;
     
     static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
                      ColsAtCompileTime = MatrixType::ColsAtCompileTime;
 
-    EiConjugate(const MatRef& matrix) : m_matrix(matrix) {}
+    Conjugate(const MatRef& matrix) : m_matrix(matrix) {}
     
-    EiConjugate(const EiConjugate& other)
+    Conjugate(const Conjugate& other)
       : m_matrix(other.m_matrix) {}
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiConjugate)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Conjugate)
     
   private:
-    EiConjugate& _ref() { return *this; }
-    const EiConjugate& _constRef() const { return *this; }
+    Conjugate& _ref() { return *this; }
+    const Conjugate& _constRef() const { return *this; }
     int _rows() const { return m_matrix.rows(); }
     int _cols() const { return m_matrix.cols(); }
     
     Scalar _read(int row, int col) const
     {
-      return EiConj(m_matrix.read(row, col));
+      return Conj(m_matrix.read(row, col));
     }
     
   protected:
@@ -60,10 +60,10 @@ template<typename MatrixType> class EiConjugate
 };
 
 template<typename Scalar, typename Derived>
-EiConjugate<Derived>
-EiObject<Scalar, Derived>::conjugate() const
+Conjugate<Derived>
+Object<Scalar, Derived>::conjugate() const
 {
-  return EiConjugate<Derived>(static_cast<const Derived*>(this)->constRef());
+  return Conjugate<Derived>(static_cast<const Derived*>(this)->constRef());
 }
 
 #endif // EI_CONJUGATE_H
diff --git a/src/Core/CopyHelper.h b/src/Core/CopyHelper.h
index ccd754c12..4bb6c31c7 100644
--- a/src/Core/CopyHelper.h
+++ b/src/Core/CopyHelper.h
@@ -1,20 +1,20 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2007 Michael Olbrich <michael.olbrich@gmx.net>
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -27,7 +27,7 @@
 #ifndef EI_COPYHELPER_H
 #define EI_COPYHELPER_H
 
-template<int UnrollCount, int Rows> struct EiCopyHelperUnroller
+template<int UnrollCount, int Rows> struct CopyHelperUnroller
 {
   static const int col = (UnrollCount-1) / Rows;
   static const int row = (UnrollCount-1) % Rows;
@@ -35,12 +35,12 @@ template<int UnrollCount, int Rows> struct EiCopyHelperUnroller
   template <typename Derived1, typename Derived2>
   static void run(Derived1 &dst, const Derived2 &src)
   {
-    EiCopyHelperUnroller<UnrollCount-1, Rows>::run(dst, src);
+    CopyHelperUnroller<UnrollCount-1, Rows>::run(dst, src);
     dst.write(row, col) = src.read(row, col);
   }
 };
 
-template<int Rows> struct EiCopyHelperUnroller<0, Rows>
+template<int Rows> struct CopyHelperUnroller<0, Rows>
 {
   template <typename Derived1, typename Derived2>
   static void run(Derived1 &dst, const Derived2 &src)
@@ -49,7 +49,7 @@ template<int Rows> struct EiCopyHelperUnroller<0, Rows>
   }
 };
 
-template<int Rows> struct EiCopyHelperUnroller<EiDynamic, Rows>
+template<int Rows> struct CopyHelperUnroller<Dynamic, Rows>
 {
   template <typename Derived1, typename Derived2>
   static void run(Derived1 &dst, const Derived2 &src)
@@ -61,10 +61,10 @@ template<int Rows> struct EiCopyHelperUnroller<EiDynamic, Rows>
 
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
-void EiObject<Scalar, Derived>::_copy_helper(const EiObject<Scalar, OtherDerived>& other)
+void Object<Scalar, Derived>::_copy_helper(const Object<Scalar, OtherDerived>& other)
 {
-  if(SizeAtCompileTime != EiDynamic && SizeAtCompileTime <= EI_LOOP_UNROLLING_LIMIT)
-    EiCopyHelperUnroller<SizeAtCompileTime, RowsAtCompileTime>::run(*this, other);
+  if(SizeAtCompileTime != Dynamic && SizeAtCompileTime <= EI_LOOP_UNROLLING_LIMIT)
+    CopyHelperUnroller<SizeAtCompileTime, RowsAtCompileTime>::run(*this, other);
   else
     for(int i = 0; i < rows(); i++)
       for(int j = 0; j < cols(); j++)
diff --git a/src/Core/Dot.h b/src/Core/Dot.h
index ea9653f8a..98adf3853 100644
--- a/src/Core/Dot.h
+++ b/src/Core/Dot.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -27,26 +27,26 @@
 #define EI_DOT_H
 
 template<int Index, int Size, typename Derived1, typename Derived2>
-struct EiDotUnroller
+struct DotUnroller
 {
   static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
   {
-    EiDotUnroller<Index-1, Size, Derived1, Derived2>::run(v1, v2, dot);
-    dot += v1[Index] * EiConj(v2[Index]);
+    DotUnroller<Index-1, Size, Derived1, Derived2>::run(v1, v2, dot);
+    dot += v1[Index] * Conj(v2[Index]);
   }
 };
 
 template<int Size, typename Derived1, typename Derived2>
-struct EiDotUnroller<0, Size, Derived1, Derived2>
+struct DotUnroller<0, Size, Derived1, Derived2>
 {
   static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
   {
-    dot = v1[0] * EiConj(v2[0]);
+    dot = v1[0] * Conj(v2[0]);
   }
 };
 
 template<int Index, typename Derived1, typename Derived2>
-struct EiDotUnroller<Index, EiDynamic, Derived1, Derived2>
+struct DotUnroller<Index, Dynamic, Derived1, Derived2>
 {
   static void run(const Derived1 &v1, const Derived2& v2, typename Derived1::Scalar &dot)
   {
@@ -58,37 +58,37 @@ struct EiDotUnroller<Index, EiDynamic, Derived1, Derived2>
 
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
-Scalar EiObject<Scalar, Derived>::dot(const OtherDerived& other) const
+Scalar Object<Scalar, Derived>::dot(const OtherDerived& other) const
 {
   assert(IsVector && OtherDerived::IsVector && size() == other.size());
   Scalar res;
-  if(SizeAtCompileTime != EiDynamic && SizeAtCompileTime <= 16)
-    EiDotUnroller<SizeAtCompileTime-1, SizeAtCompileTime, Derived, OtherDerived>
+  if(SizeAtCompileTime != Dynamic && SizeAtCompileTime <= 16)
+    DotUnroller<SizeAtCompileTime-1, SizeAtCompileTime, Derived, OtherDerived>
       ::run(*static_cast<const Derived*>(this), other, res);
   else
   {
-    res = (*this)[0] * EiConj(other[0]);
+    res = (*this)[0] * Conj(other[0]);
     for(int i = 1; i < size(); i++)
-      res += (*this)[i]* EiConj(other[i]);
+      res += (*this)[i]* Conj(other[i]);
   }
   return res;
 }
 
 template<typename Scalar, typename Derived>
-typename EiNumTraits<Scalar>::Real EiObject<Scalar, Derived>::norm2() const
+typename NumTraits<Scalar>::Real Object<Scalar, Derived>::norm2() const
 {
   assert(IsVector);
-  return EiReal(dot(*this));
+  return Real(dot(*this));
 }
 
 template<typename Scalar, typename Derived>
-typename EiNumTraits<Scalar>::Real EiObject<Scalar, Derived>::norm() const
+typename NumTraits<Scalar>::Real Object<Scalar, Derived>::norm() const
 {
-  return EiSqrt(norm2());
+  return Sqrt(norm2());
 }
 
 template<typename Scalar, typename Derived>
-EiScalarProduct<Derived> EiObject<Scalar, Derived>::normalized() const
+ScalarProduct<Derived> Object<Scalar, Derived>::normalized() const
 {
   return (*this) / norm();
 }
diff --git a/src/Core/Eval.h b/src/Core/Eval.h
index 4de32ebac..5551d8e21 100644
--- a/src/Core/Eval.h
+++ b/src/Core/Eval.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,26 +26,26 @@
 #ifndef EI_EVAL_H
 #define EI_EVAL_H
 
-template<typename Expression> class EiEval
-  : public EiMatrix< typename Expression::Scalar,
+template<typename Expression> class Eval
+  : public Matrix< typename Expression::Scalar,
                      Expression::RowsAtCompileTime,
                      Expression::ColsAtCompileTime >
 {
   public:
     typedef typename Expression::Scalar Scalar;
-    typedef EiMatrix<Scalar, Expression::RowsAtCompileTime, Expression::ColsAtCompileTime> MatrixType;
+    typedef Matrix<Scalar, Expression::RowsAtCompileTime, Expression::ColsAtCompileTime> MatrixType;
     typedef Expression Base;
-    friend class EiObject<Scalar, Expression>;
+    friend class Object<Scalar, Expression>;
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiEval)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Eval)
     
-    EiEval(const Expression& expression) : MatrixType(expression) {}
+    Eval(const Expression& expression) : MatrixType(expression) {}
 };
 
 template<typename Scalar, typename Derived>
-EiEval<Derived> EiObject<Scalar, Derived>::eval() const
+Eval<Derived> Object<Scalar, Derived>::eval() const
 {
-  return EiEval<Derived>(*static_cast<const Derived*>(this));
+  return Eval<Derived>(*static_cast<const Derived*>(this));
 }
 
 #endif // EI_EVAL_H
diff --git a/src/Core/Fuzzy.h b/src/Core/Fuzzy.h
index 44b20615d..8730a073b 100644
--- a/src/Core/Fuzzy.h
+++ b/src/Core/Fuzzy.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -28,13 +28,13 @@
 
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
-bool EiObject<Scalar, Derived>::isApprox(const OtherDerived& other) const
+bool Object<Scalar, Derived>::isApprox(const OtherDerived& other) const
 {
   if(IsVector)
   {
     return((*this - other).norm2()
            <= std::min(norm2(), other.norm2())
-            * EiAbs2(EiNumTraits<Scalar>::epsilon()));
+            * Abs2(NumTraits<Scalar>::epsilon()));
   }
   else
   {
@@ -46,11 +46,11 @@ bool EiObject<Scalar, Derived>::isApprox(const OtherDerived& other) const
 }
 
 template<typename Scalar, typename Derived>
-bool EiObject<Scalar, Derived>::isNegligble(const Scalar& other) const
+bool Object<Scalar, Derived>::isNegligble(const Scalar& other) const
 {
   if(IsVector)
   {
-    return(norm2() <= EiAbs2(other) * EiAbs2(EiNumTraits<Scalar>::epsilon()));
+    return(norm2() <= Abs2(other) * Abs2(NumTraits<Scalar>::epsilon()));
   }
   else
   {
@@ -63,11 +63,11 @@ bool EiObject<Scalar, Derived>::isNegligble(const Scalar& other) const
 
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
-bool EiObject<Scalar, Derived>::isNegligble(const EiObject<Scalar, OtherDerived>& other) const
+bool Object<Scalar, Derived>::isNegligble(const Object<Scalar, OtherDerived>& other) const
 {
   if(IsVector)
   {
-    return(norm2() <= other.norm2() * EiAbs2(EiNumTraits<Scalar>::epsilon()));
+    return(norm2() <= other.norm2() * Abs2(NumTraits<Scalar>::epsilon()));
   }
   else
   {
diff --git a/src/Core/Matrix.h b/src/Core/Matrix.h
index b4df04b11..a87de43ac 100644
--- a/src/Core/Matrix.h
+++ b/src/Core/Matrix.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -33,18 +33,18 @@
 #include "MatrixStorage.h"
 
 template<typename _Scalar, int _Rows, int _Cols>
-class EiMatrix : public EiObject<_Scalar, EiMatrix<_Scalar, _Rows, _Cols> >,
-                 public EiMatrixStorage<_Scalar, _Rows, _Cols>
+class Matrix : public Object<_Scalar, Matrix<_Scalar, _Rows, _Cols> >,
+                 public MatrixStorage<_Scalar, _Rows, _Cols>
 {
   public:
-    friend class EiObject<_Scalar, EiMatrix>;
-    typedef      EiObject<_Scalar, EiMatrix>            Base;
-    typedef      EiMatrixStorage<_Scalar, _Rows, _Cols> Storage;
+    friend class Object<_Scalar, Matrix>;
+    typedef      Object<_Scalar, Matrix>            Base;
+    typedef      MatrixStorage<_Scalar, _Rows, _Cols> Storage;
     typedef      _Scalar                                Scalar;
-    typedef      EiMatrixRef<EiMatrix>                  Ref;
-    typedef      EiMatrixConstRef<EiMatrix>             ConstRef;
-    friend class EiMatrixRef<EiMatrix>;
-    friend class EiMatrixConstRef<EiMatrix>;
+    typedef      MatrixRef<Matrix>                  Ref;
+    typedef      MatrixConstRef<Matrix>             ConstRef;
+    friend class MatrixRef<Matrix>;
+    friend class MatrixConstRef<Matrix>;
     
     static const int RowsAtCompileTime = _Rows, ColsAtCompileTime = _Cols;
     
@@ -72,46 +72,46 @@ class EiMatrix : public EiObject<_Scalar, EiMatrix<_Scalar, _Rows, _Cols> >,
     
   public:
     template<typename OtherDerived> 
-    EiMatrix& operator=(const EiObject<Scalar, OtherDerived>& other)
+    Matrix& operator=(const Object<Scalar, OtherDerived>& other)
     {
       resize(other.rows(), other.cols());
       return Base::operator=(other);
     }
     
-    EiMatrix& operator=(const EiMatrix& other)
+    Matrix& operator=(const Matrix& other)
     {
       resize(other.rows(), other.cols());
       return Base::operator=(other);
     }
     
-    EI_INHERIT_ASSIGNMENT_OPERATOR(EiMatrix, +=)
-    EI_INHERIT_ASSIGNMENT_OPERATOR(EiMatrix, -=)
-    EI_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(EiMatrix, *=)
-    EI_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(EiMatrix, /=)
+    EI_INHERIT_ASSIGNMENT_OPERATOR(Matrix, +=)
+    EI_INHERIT_ASSIGNMENT_OPERATOR(Matrix, -=)
+    EI_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Matrix, *=)
+    EI_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Matrix, /=)
     
-    explicit EiMatrix(int rows = 1, int cols = 1) : Storage(rows, cols) {}
+    explicit Matrix(int rows = 1, int cols = 1) : Storage(rows, cols) {}
     template<typename OtherDerived>
-    EiMatrix(const EiObject<Scalar, OtherDerived>& other) : Storage(other.rows(), other.cols())
+    Matrix(const Object<Scalar, OtherDerived>& other) : Storage(other.rows(), other.cols())
     {
       *this = other;
     }
-    EiMatrix(const EiMatrix& other) : Storage(other.rows(), other.cols())
+    Matrix(const Matrix& other) : Storage(other.rows(), other.cols())
     {
       *this = other;
     }
-    ~EiMatrix() {}
+    ~Matrix() {}
 };
 
 #define EI_MAKE_TYPEDEFS(Type, TypeSuffix, Size, SizeSuffix) \
-typedef EiMatrix<Type, Size, Size> EiMatrix##SizeSuffix##TypeSuffix; \
-typedef EiMatrix<Type, Size, 1>    EiVector##SizeSuffix##TypeSuffix; \
-typedef EiMatrix<Type, 1, Size>    EiRowVector##SizeSuffix##TypeSuffix;
+typedef Matrix<Type, Size, Size> Matrix##SizeSuffix##TypeSuffix; \
+typedef Matrix<Type, Size, 1>    Vector##SizeSuffix##TypeSuffix; \
+typedef Matrix<Type, 1, Size>    RowVector##SizeSuffix##TypeSuffix;
 
 #define EI_MAKE_TYPEDEFS_ALL_SIZES(Type, TypeSuffix) \
 EI_MAKE_TYPEDEFS(Type, TypeSuffix, 2, 2) \
 EI_MAKE_TYPEDEFS(Type, TypeSuffix, 3, 3) \
 EI_MAKE_TYPEDEFS(Type, TypeSuffix, 4, 4) \
-EI_MAKE_TYPEDEFS(Type, TypeSuffix, EiDynamic, X)
+EI_MAKE_TYPEDEFS(Type, TypeSuffix, Dynamic, X)
 
 EI_MAKE_TYPEDEFS_ALL_SIZES(int,                  i)
 EI_MAKE_TYPEDEFS_ALL_SIZES(float,                f)
@@ -123,6 +123,25 @@ EI_MAKE_TYPEDEFS_ALL_SIZES(std::complex<double>, cd)
 #undef EI_MAKE_TYPEDEFS_ALL_SIZES
 #undef EI_MAKE_TYPEDEFS
 
+#define EI_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(Type, TypeSuffix, Size, SizeSuffix) \
+using Eigen::Matrix##SizeSuffix##TypeSuffix; \
+using Eigen::Vector##SizeSuffix##TypeSuffix; \
+using Eigen::RowVector##SizeSuffix##TypeSuffix;
+
+#define EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(Type, TypeSuffix) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(Type, TypeSuffix, 2, 2) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(Type, TypeSuffix, 3, 3) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(Type, TypeSuffix, 4, 4) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE_AND_SIZE(Type, TypeSuffix, Dynamic, X)
+
+#define EI_USING_MATRIX_TYPEDEFS \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(int,                  i) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(float,                f) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(double,               d) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(std::complex<int>,    ci) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(std::complex<float>,  cf) \
+EI_USING_MATRIX_TYPEDEFS_FOR_TYPE(std::complex<double>, cd)
+
 #include "Eval.h"
 #include "MatrixOps.h"
 #include "ScalarOps.h"
diff --git a/src/Core/MatrixOps.h b/src/Core/MatrixOps.h
index 1449a3923..0861a2bff 100644
--- a/src/Core/MatrixOps.h
+++ b/src/Core/MatrixOps.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,33 +26,33 @@
 #ifndef EI_MATRIXOPS_H
 #define EI_MATRIXOPS_H
 
-template<typename Lhs, typename Rhs> class EiSum
-  : public EiObject<typename Lhs::Scalar, EiSum<Lhs, Rhs> >
+template<typename Lhs, typename Rhs> class Sum
+  : public Object<typename Lhs::Scalar, Sum<Lhs, Rhs> >
 {
   public:
     typedef typename Lhs::Scalar Scalar;
     typedef typename Lhs::ConstRef LhsRef;
     typedef typename Rhs::ConstRef RhsRef;
-    friend class EiObject<Scalar, EiSum>;
+    friend class Object<Scalar, Sum>;
     
     static const int RowsAtCompileTime = Lhs::RowsAtCompileTime,
                      ColsAtCompileTime = Rhs::ColsAtCompileTime;
 
-    EiSum(const LhsRef& lhs, const RhsRef& rhs)
+    Sum(const LhsRef& lhs, const RhsRef& rhs)
       : m_lhs(lhs), m_rhs(rhs)
     {
       assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
     }
 
-    EiSum(const EiSum& other)
+    Sum(const Sum& other)
       : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {}
       
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiSum)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Sum)
 
   private:
   
-    const EiSum& _ref() const { return *this; }
-    const EiSum& _constRef() const { return *this; }
+    const Sum& _ref() const { return *this; }
+    const Sum& _constRef() const { return *this; }
     int _rows() const { return m_lhs.rows(); }
     int _cols() const { return m_lhs.cols(); }
 
@@ -66,32 +66,32 @@ template<typename Lhs, typename Rhs> class EiSum
     const RhsRef m_rhs;
 };
 
-template<typename Lhs, typename Rhs> class EiDifference
-  : public EiObject<typename Lhs::Scalar, EiDifference<Lhs, Rhs> >
+template<typename Lhs, typename Rhs> class Difference
+  : public Object<typename Lhs::Scalar, Difference<Lhs, Rhs> >
 {
   public:
     typedef typename Lhs::Scalar Scalar;
     typedef typename Lhs::ConstRef LhsRef;
     typedef typename Rhs::ConstRef RhsRef;
-    friend class EiObject<Scalar, EiDifference>;
+    friend class Object<Scalar, Difference>;
     
     static const int RowsAtCompileTime = Lhs::RowsAtCompileTime,
                      ColsAtCompileTime = Rhs::ColsAtCompileTime;
     
-    EiDifference(const LhsRef& lhs, const RhsRef& rhs)
+    Difference(const LhsRef& lhs, const RhsRef& rhs)
       : m_lhs(lhs), m_rhs(rhs)
     {
       assert(lhs.rows() == rhs.rows() && lhs.cols() == rhs.cols());
     }
 
-    EiDifference(const EiDifference& other)
+    Difference(const Difference& other)
       : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {}
 
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiDifference)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Difference)
 
   private:
-    const EiDifference& _ref() const { return *this; }
-    const EiDifference& _constRef() const { return *this; }
+    const Difference& _ref() const { return *this; }
+    const Difference& _constRef() const { return *this; }
     int _rows() const { return m_lhs.rows(); }
     int _cols() const { return m_lhs.cols(); }
 
@@ -106,18 +106,18 @@ template<typename Lhs, typename Rhs> class EiDifference
 };
 
 template<int Index, int Size, typename Lhs, typename Rhs>
-struct EiMatrixProductUnroller
+struct MatrixProductUnroller
 {
   static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
                   typename Lhs::Scalar &res)
   {
-    EiMatrixProductUnroller<Index-1, Size, Lhs, Rhs>::run(row, col, lhs, rhs, res);
+    MatrixProductUnroller<Index-1, Size, Lhs, Rhs>::run(row, col, lhs, rhs, res);
     res += lhs.read(row, Index) * rhs.read(Index, col);
   }
 };
 
 template<int Size, typename Lhs, typename Rhs>
-struct EiMatrixProductUnroller<0, Size, Lhs, Rhs>
+struct MatrixProductUnroller<0, Size, Lhs, Rhs>
 {
   static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
                   typename Lhs::Scalar &res)
@@ -127,7 +127,7 @@ struct EiMatrixProductUnroller<0, Size, Lhs, Rhs>
 };
 
 template<int Index, typename Lhs, typename Rhs>
-struct EiMatrixProductUnroller<Index, EiDynamic, Lhs, Rhs>
+struct MatrixProductUnroller<Index, Dynamic, Lhs, Rhs>
 {
   static void run(int row, int col, const Lhs& lhs, const Rhs& rhs,
                   typename Lhs::Scalar &res)
@@ -140,40 +140,40 @@ struct EiMatrixProductUnroller<Index, EiDynamic, Lhs, Rhs>
   }
 };
 
-template<typename Lhs, typename Rhs> class EiMatrixProduct
-  : public EiObject<typename Lhs::Scalar, EiMatrixProduct<Lhs, Rhs> >
+template<typename Lhs, typename Rhs> class MatrixProduct
+  : public Object<typename Lhs::Scalar, MatrixProduct<Lhs, Rhs> >
 {
   public:
     typedef typename Lhs::Scalar Scalar;
     typedef typename Lhs::ConstRef LhsRef;
     typedef typename Rhs::ConstRef RhsRef;
-    friend class EiObject<Scalar, EiMatrixProduct>;
+    friend class Object<Scalar, MatrixProduct>;
     
     static const int RowsAtCompileTime = Lhs::RowsAtCompileTime,
                      ColsAtCompileTime = Rhs::ColsAtCompileTime;
 
-    EiMatrixProduct(const LhsRef& lhs, const RhsRef& rhs)
+    MatrixProduct(const LhsRef& lhs, const RhsRef& rhs)
       : m_lhs(lhs), m_rhs(rhs) 
     {
       assert(lhs.cols() == rhs.rows());
     }
     
-    EiMatrixProduct(const EiMatrixProduct& other)
+    MatrixProduct(const MatrixProduct& other)
       : m_lhs(other.m_lhs), m_rhs(other.m_rhs) {}
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiMatrixProduct)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(MatrixProduct)
     
   private:
-    const EiMatrixProduct& _ref() const { return *this; }
-    const EiMatrixProduct& _constRef() const { return *this; }
+    const MatrixProduct& _ref() const { return *this; }
+    const MatrixProduct& _constRef() const { return *this; }
     int _rows() const { return m_lhs.rows(); }
     int _cols() const { return m_rhs.cols(); }
     
     Scalar _read(int row, int col) const
     {
       Scalar res;
-      if(Lhs::ColsAtCompileTime != EiDynamic && Lhs::ColsAtCompileTime <= 16)
-        EiMatrixProductUnroller<Lhs::ColsAtCompileTime-1, Lhs::ColsAtCompileTime, LhsRef, RhsRef>
+      if(Lhs::ColsAtCompileTime != Dynamic && Lhs::ColsAtCompileTime <= 16)
+        MatrixProductUnroller<Lhs::ColsAtCompileTime-1, Lhs::ColsAtCompileTime, LhsRef, RhsRef>
           ::run(row, col, m_lhs, m_rhs, res);
       else
       {
@@ -190,30 +190,30 @@ template<typename Lhs, typename Rhs> class EiMatrixProduct
 };
 
 template<typename Scalar, typename Derived1, typename Derived2>
-EiSum<Derived1, Derived2>
-operator+(const EiObject<Scalar, Derived1> &mat1, const EiObject<Scalar, Derived2> &mat2)
+Sum<Derived1, Derived2>
+operator+(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &mat2)
 {
-  return EiSum<Derived1, Derived2>(mat1.constRef(), mat2.constRef());
+  return Sum<Derived1, Derived2>(mat1.constRef(), mat2.constRef());
 }
 
 template<typename Scalar, typename Derived1, typename Derived2>
-EiDifference<Derived1, Derived2>
-operator-(const EiObject<Scalar, Derived1> &mat1, const EiObject<Scalar, Derived2> &mat2)
+Difference<Derived1, Derived2>
+operator-(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &mat2)
 {
-  return EiDifference<Derived1, Derived2>(mat1.constRef(), mat2.constRef());
+  return Difference<Derived1, Derived2>(mat1.constRef(), mat2.constRef());
 }
 
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
-EiMatrixProduct<Derived, OtherDerived>
-EiObject<Scalar, Derived>::lazyMul(const EiObject<Scalar, OtherDerived> &other) const
+MatrixProduct<Derived, OtherDerived>
+Object<Scalar, Derived>::lazyMul(const Object<Scalar, OtherDerived> &other) const
 {
-  return EiMatrixProduct<Derived, OtherDerived>(constRef(), other.constRef());
+  return MatrixProduct<Derived, OtherDerived>(constRef(), other.constRef());
 }
 
 template<typename Scalar, typename Derived1, typename Derived2>
-EiEval<EiMatrixProduct<Derived1, Derived2> >
-operator*(const EiObject<Scalar, Derived1> &mat1, const EiObject<Scalar, Derived2> &mat2)
+Eval<MatrixProduct<Derived1, Derived2> >
+operator*(const Object<Scalar, Derived1> &mat1, const Object<Scalar, Derived2> &mat2)
 {
   return mat1.lazyMul(mat2).eval();
 }
@@ -221,7 +221,7 @@ operator*(const EiObject<Scalar, Derived1> &mat1, const EiObject<Scalar, Derived
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
 Derived &
-EiObject<Scalar, Derived>::operator+=(const EiObject<Scalar, OtherDerived>& other)
+Object<Scalar, Derived>::operator+=(const Object<Scalar, OtherDerived>& other)
 {
   return *this = *this + other;
 }
@@ -229,7 +229,7 @@ EiObject<Scalar, Derived>::operator+=(const EiObject<Scalar, OtherDerived>& othe
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
 Derived &
-EiObject<Scalar, Derived>::operator-=(const EiObject<Scalar, OtherDerived> &other)
+Object<Scalar, Derived>::operator-=(const Object<Scalar, OtherDerived> &other)
 {
   return *this = *this - other;
 }
@@ -237,7 +237,7 @@ EiObject<Scalar, Derived>::operator-=(const EiObject<Scalar, OtherDerived> &othe
 template<typename Scalar, typename Derived>
 template<typename OtherDerived>
 Derived &
-EiObject<Scalar, Derived>::operator*=(const EiObject<Scalar, OtherDerived> &other)
+Object<Scalar, Derived>::operator*=(const Object<Scalar, OtherDerived> &other)
 {
   return *this = *this * other;
 }
diff --git a/src/Core/MatrixRef.h b/src/Core/MatrixRef.h
index 7bf3ebe44..d3fdae581 100644
--- a/src/Core/MatrixRef.h
+++ b/src/Core/MatrixRef.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,18 +26,18 @@
 #ifndef EI_MATRIXREF_H
 #define EI_MATRIXREF_H
 
-template<typename MatrixType> class EiMatrixConstRef
- : public EiObject<typename MatrixType::Scalar, EiMatrixConstRef<MatrixType> >
+template<typename MatrixType> class MatrixConstRef
+ : public Object<typename MatrixType::Scalar, MatrixConstRef<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
-    friend class EiObject<Scalar, EiMatrixConstRef>;
+    friend class Object<Scalar, MatrixConstRef>;
     
-    EiMatrixConstRef(const MatrixType& matrix) : m_matrix(matrix) {}
-    EiMatrixConstRef(const EiMatrixConstRef& other) : m_matrix(other.m_matrix) {}
-    ~EiMatrixConstRef() {}
+    MatrixConstRef(const MatrixType& matrix) : m_matrix(matrix) {}
+    MatrixConstRef(const MatrixConstRef& other) : m_matrix(other.m_matrix) {}
+    ~MatrixConstRef() {}
 
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiMatrixConstRef)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(MatrixConstRef)
 
   private:
     int _rows() const { return m_matrix.rows(); }
@@ -51,18 +51,18 @@ template<typename MatrixType> class EiMatrixConstRef
     const MatrixType& m_matrix;
 };
 
-template<typename MatrixType> class EiMatrixRef
- : public EiObject<typename MatrixType::Scalar, EiMatrixRef<MatrixType> >
+template<typename MatrixType> class MatrixRef
+ : public Object<typename MatrixType::Scalar, MatrixRef<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
-    friend class EiObject<Scalar, EiMatrixRef>;
+    friend class Object<Scalar, MatrixRef>;
     
-    EiMatrixRef(MatrixType& matrix) : m_matrix(matrix) {}
-    EiMatrixRef(const EiMatrixRef& other) : m_matrix(other.m_matrix) {}
-    ~EiMatrixRef() {}
+    MatrixRef(MatrixType& matrix) : m_matrix(matrix) {}
+    MatrixRef(const MatrixRef& other) : m_matrix(other.m_matrix) {}
+    ~MatrixRef() {}
 
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiMatrixRef)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(MatrixRef)
 
   private:
     int _rows() const { return m_matrix.rows(); }
diff --git a/src/Core/MatrixStorage.h b/src/Core/MatrixStorage.h
index b3b3f9e06..1fbc96ebc 100644
--- a/src/Core/MatrixStorage.h
+++ b/src/Core/MatrixStorage.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -29,7 +29,7 @@
 template<typename Scalar,
          int      RowsAtCompileTime,
          int      ColsAtCompileTime>
-class EiMatrixStorage
+class MatrixStorage
 {
   protected:
     Scalar m_array[RowsAtCompileTime * ColsAtCompileTime];
@@ -44,18 +44,18 @@ class EiMatrixStorage
     { return ColsAtCompileTime; }
 
   public:
-    EiMatrixStorage(int rows, int cols)
+    MatrixStorage(int rows, int cols)
     {
       EI_UNUSED(rows);
       EI_UNUSED(cols);
       assert(RowsAtCompileTime > 0 && ColsAtCompileTime > 0);
     }
     
-    ~EiMatrixStorage() {};
+    ~MatrixStorage() {};
 };
 
 template<typename Scalar, int ColsAtCompileTime>
-class EiMatrixStorage<Scalar, EiDynamic, ColsAtCompileTime>
+class MatrixStorage<Scalar, Dynamic, ColsAtCompileTime>
 {
   protected:
     int m_rows;
@@ -79,18 +79,18 @@ class EiMatrixStorage<Scalar, EiDynamic, ColsAtCompileTime>
     { return ColsAtCompileTime; }
     
   public:
-    EiMatrixStorage(int rows, int cols) : m_rows(rows)
+    MatrixStorage(int rows, int cols) : m_rows(rows)
     {
       assert(m_rows > 0 && cols == ColsAtCompileTime);
       m_array = new Scalar[m_rows * ColsAtCompileTime];
     }
     
-    ~EiMatrixStorage()
+    ~MatrixStorage()
     { delete[] m_array; }
 };
 
 template<typename Scalar, int RowsAtCompileTime>
-class EiMatrixStorage<Scalar, RowsAtCompileTime, EiDynamic>
+class MatrixStorage<Scalar, RowsAtCompileTime, Dynamic>
 {
   protected:
     int m_cols;
@@ -114,18 +114,18 @@ class EiMatrixStorage<Scalar, RowsAtCompileTime, EiDynamic>
     { return m_cols; }
     
   public:
-    EiMatrixStorage(int rows, int cols) : m_cols(cols)
+    MatrixStorage(int rows, int cols) : m_cols(cols)
     {
       assert(rows == RowsAtCompileTime && cols > 0);
       m_array = new Scalar[m_cols * RowsAtCompileTime];
     }
     
-    ~EiMatrixStorage()
+    ~MatrixStorage()
     { delete[] m_array; }
 };
 
 template<typename Scalar>
-class EiMatrixStorage<Scalar, EiDynamic, EiDynamic>
+class MatrixStorage<Scalar, Dynamic, Dynamic>
 {
   protected:
     int m_rows, m_cols;
@@ -150,13 +150,13 @@ class EiMatrixStorage<Scalar, EiDynamic, EiDynamic>
     { return m_cols; }
     
   public:
-    EiMatrixStorage(int rows, int cols) : m_rows(rows), m_cols(cols)
+    MatrixStorage(int rows, int cols) : m_rows(rows), m_cols(cols)
     {
       assert(m_rows > 0 && m_cols > 0);
       m_array = new Scalar[m_rows * m_cols];
     }
     
-    ~EiMatrixStorage()
+    ~MatrixStorage()
     { delete[] m_array; }
 };
 
diff --git a/src/Core/Minor.h b/src/Core/Minor.h
index 217ee9059..11ca541bc 100644
--- a/src/Core/Minor.h
+++ b/src/Core/Minor.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,35 +26,35 @@
 #ifndef EI_MINOR_H
 #define EI_MINOR_H
 
-template<typename MatrixType> class EiMinor
-  : public EiObject<typename MatrixType::Scalar, EiMinor<MatrixType> >
+template<typename MatrixType> class Minor
+  : public Object<typename MatrixType::Scalar, Minor<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Ref MatRef;
-    friend class EiObject<Scalar, EiMinor<MatrixType> >;
+    friend class Object<Scalar, Minor<MatrixType> >;
     
     static const int
-      RowsAtCompileTime = (MatrixType::RowsAtCompileTime != EiDynamic) ?
-                          MatrixType::RowsAtCompileTime - 1 : EiDynamic,
-      ColsAtCompileTime = (MatrixType::ColsAtCompileTime != EiDynamic) ?
-                          MatrixType::ColsAtCompileTime - 1 : EiDynamic;
+      RowsAtCompileTime = (MatrixType::RowsAtCompileTime != Dynamic) ?
+                          MatrixType::RowsAtCompileTime - 1 : Dynamic,
+      ColsAtCompileTime = (MatrixType::ColsAtCompileTime != Dynamic) ?
+                          MatrixType::ColsAtCompileTime - 1 : Dynamic;
 
-    EiMinor(const MatRef& matrix,
+    Minor(const MatRef& matrix,
                 int row, int col = 0)
       : m_matrix(matrix), m_row(row), m_col(col)
     {
       EI_CHECK_RANGES(matrix, row, col);
     }
     
-    EiMinor(const EiMinor& other)
+    Minor(const Minor& other)
       : m_matrix(other.m_matrix), m_row(other.m_row), m_col(other.m_col) {}
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiMinor)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Minor)
     
   private:
-    EiMinor& _ref() { return *this; }
-    const EiMinor& _constRef() const { return *this; }
+    Minor& _ref() { return *this; }
+    const Minor& _constRef() const { return *this; }
     int _rows() const { return m_matrix.rows() - 1; }
     int _cols() const { return m_matrix.cols() - 1; }
     
@@ -74,10 +74,10 @@ template<typename MatrixType> class EiMinor
 };
 
 template<typename Scalar, typename Derived>
-EiMinor<Derived>
-EiObject<Scalar, Derived>::minor(int row, int col)
+Minor<Derived>
+Object<Scalar, Derived>::minor(int row, int col)
 {
-  return EiMinor<Derived>(static_cast<Derived*>(this)->ref(), row, col);
+  return Minor<Derived>(static_cast<Derived*>(this)->ref(), row, col);
 }
 
 #endif // EI_MINOR_H
diff --git a/src/Core/Numeric.h b/src/Core/Numeric.h
index 23a6c03e6..264c7a549 100644
--- a/src/Core/Numeric.h
+++ b/src/Core/Numeric.h
@@ -1,20 +1,20 @@
 
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -27,9 +27,9 @@
 #ifndef EI_NUMERIC_H
 #define EI_NUMERIC_H
 
-template<typename T> struct EiNumTraits;
+template<typename T> struct NumTraits;
 
-template<> struct EiNumTraits<int>
+template<> struct NumTraits<int>
 {
   typedef int Real;
   typedef double FloatingPoint;
@@ -54,7 +54,7 @@ template<> struct EiNumTraits<int>
   }
 };
 
-template<> struct EiNumTraits<float>
+template<> struct NumTraits<float>
 {
   typedef float Real;
   typedef float FloatingPoint;
@@ -76,7 +76,7 @@ template<> struct EiNumTraits<float>
   }
 };
 
-template<> struct EiNumTraits<double>
+template<> struct NumTraits<double>
 {
   typedef double Real;
   typedef double FloatingPoint;
@@ -98,17 +98,17 @@ template<> struct EiNumTraits<double>
   }
 };
 
-template<typename _Real> struct EiNumTraits<std::complex<_Real> >
+template<typename _Real> struct NumTraits<std::complex<_Real> >
 {
   typedef _Real Real;
   typedef std::complex<Real> Complex;
   typedef std::complex<double> FloatingPoint;
-  typedef typename EiNumTraits<Real>::FloatingPoint RealFloatingPoint;
+  typedef typename NumTraits<Real>::FloatingPoint RealFloatingPoint;
   
   static const bool IsComplex = true;
-  static const bool HasFloatingPoint = EiNumTraits<Real>::HasFloatingPoint;
+  static const bool HasFloatingPoint = NumTraits<Real>::HasFloatingPoint;
   
-  static Real epsilon() { return EiNumTraits<Real>::epsilon(); }
+  static Real epsilon() { return NumTraits<Real>::epsilon(); }
   static Real real(const Complex& x) { return std::real(x); }
   static Real imag(const Complex& x) { return std::imag(x); }
   static Complex conj(const Complex& x) { return std::conj(x); }
@@ -120,48 +120,48 @@ template<typename _Real> struct EiNumTraits<std::complex<_Real> >
   { return std::real(x) * std::real(x) + std::imag(x) * std::imag(x); }
   static Complex rand()
   {
-    return Complex(EiNumTraits<Real>::rand(), EiNumTraits<Real>::rand());
+    return Complex(NumTraits<Real>::rand(), NumTraits<Real>::rand());
   }
 };
 
-template<typename T> typename EiNumTraits<T>::Real EiReal(const T& x)
-{ return EiNumTraits<T>::real(x); }
+template<typename T> typename NumTraits<T>::Real Real(const T& x)
+{ return NumTraits<T>::real(x); }
 
-template<typename T> typename EiNumTraits<T>::Real EiImag(const T& x)
-{ return EiNumTraits<T>::imag(x); }
+template<typename T> typename NumTraits<T>::Real Imag(const T& x)
+{ return NumTraits<T>::imag(x); }
 
-template<typename T> T EiConj(const T& x)
-{ return EiNumTraits<T>::conj(x); }
+template<typename T> T Conj(const T& x)
+{ return NumTraits<T>::conj(x); }
 
-template<typename T> typename EiNumTraits<T>::FloatingPoint EiSqrt(const T& x)
-{ return EiNumTraits<T>::sqrt(x); }
+template<typename T> typename NumTraits<T>::FloatingPoint Sqrt(const T& x)
+{ return NumTraits<T>::sqrt(x); }
 
-template<typename T> typename EiNumTraits<T>::RealFloatingPoint EiAbs(const T& x)
-{ return EiNumTraits<T>::abs(x); }
+template<typename T> typename NumTraits<T>::RealFloatingPoint Abs(const T& x)
+{ return NumTraits<T>::abs(x); }
 
-template<typename T> typename EiNumTraits<T>::Real EiAbs2(const T& x)
-{ return EiNumTraits<T>::abs2(x); }
+template<typename T> typename NumTraits<T>::Real Abs2(const T& x)
+{ return NumTraits<T>::abs2(x); }
 
-template<typename T> T EiRand()
-{ return EiNumTraits<T>::rand(); }
+template<typename T> T Rand()
+{ return NumTraits<T>::rand(); }
 
-template<typename T> bool EiNegligible(const T& a, const T& b)
+template<typename T> bool Negligible(const T& a, const T& b)
 {
-  return(EiAbs(a) <= EiAbs(b) * EiNumTraits<T>::epsilon());
+  return(Abs(a) <= Abs(b) * NumTraits<T>::epsilon());
 }
 
-template<typename T> bool EiApprox(const T& a, const T& b)
+template<typename T> bool Approx(const T& a, const T& b)
 {
-  if(EiNumTraits<T>::IsFloat)
-    return(EiAbs(a - b) <= std::min(EiAbs(a), EiAbs(b)) * EiNumTraits<T>::epsilon());
+  if(NumTraits<T>::IsFloat)
+    return(Abs(a - b) <= std::min(Abs(a), Abs(b)) * NumTraits<T>::epsilon());
   else
     return(a == b);
 }
 
-template<typename T> bool EiLessThanOrApprox(const T& a, const T& b)
+template<typename T> bool LessThanOrApprox(const T& a, const T& b)
 {
-  if(EiNumTraits<T>::IsFloat)
-    return(a < b || EiApprox(a, b));
+  if(NumTraits<T>::IsFloat)
+    return(a < b || Approx(a, b));
   else
     return(a <= b);
 }
diff --git a/src/Core/Object.h b/src/Core/Object.h
index d1a310a20..f8d1cb174 100644
--- a/src/Core/Object.h
+++ b/src/Core/Object.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,23 +26,23 @@
 #ifndef EI_OBJECT_H
 #define EI_OBJECT_H
 
-template<typename Scalar, typename Derived> class EiObject
+template<typename Scalar, typename Derived> class Object
 {
     static const int RowsAtCompileTime = Derived::RowsAtCompileTime,
                      ColsAtCompileTime = Derived::ColsAtCompileTime;
     
     template<typename OtherDerived>
-    void _copy_helper(const EiObject<Scalar, OtherDerived>& other);
+    void _copy_helper(const Object<Scalar, OtherDerived>& other);
     
   public:
     static const int SizeAtCompileTime
-      = RowsAtCompileTime == EiDynamic || ColsAtCompileTime == EiDynamic
-      ? EiDynamic : RowsAtCompileTime * ColsAtCompileTime;
+      = RowsAtCompileTime == Dynamic || ColsAtCompileTime == Dynamic
+      ? Dynamic : RowsAtCompileTime * ColsAtCompileTime;
     static const bool IsVector = RowsAtCompileTime == 1 || ColsAtCompileTime == 1;
     
-    typedef typename EiForwardDecl<Derived>::Ref Ref;
-    typedef typename EiForwardDecl<Derived>::ConstRef ConstRef;
-    typedef typename EiNumTraits<Scalar>::Real RealScalar;
+    typedef typename ForwardDecl<Derived>::Ref Ref;
+    typedef typename ForwardDecl<Derived>::ConstRef ConstRef;
+    typedef typename NumTraits<Scalar>::Real RealScalar;
   
     int rows() const { return static_cast<const Derived *>(this)->_rows(); }
     int cols() const { return static_cast<const Derived *>(this)->_cols(); }
@@ -65,7 +65,7 @@ template<typename Scalar, typename Derived> class EiObject
     }
     
     template<typename OtherDerived>
-    Derived& operator=(const EiObject<Scalar, OtherDerived>& other)
+    Derived& operator=(const Object<Scalar, OtherDerived>& other)
     {
       assert(rows() == other.rows() && cols() == other.cols());
       _copy_helper(other);
@@ -74,20 +74,20 @@ template<typename Scalar, typename Derived> class EiObject
     
     //special case of the above template operator=. Strangely, g++ 4.1 failed to use
     //that template when OtherDerived == Derived
-    Derived& operator=(const EiObject& other)
+    Derived& operator=(const Object& other)
     {
       assert(rows() == other.rows() && cols() == other.cols());
       _copy_helper(other);
       return *static_cast<Derived*>(this);
     }
     
-    EiRow<Derived> row(int i);
-    EiColumn<Derived> col(int i);
-    EiMinor<Derived> minor(int row, int col);
-    EiBlock<Derived> block(int startRow, int endRow, int startCol, int endCol);
-    EiTranspose<Derived> transpose();
-    EiConjugate<Derived> conjugate() const;
-    EiTranspose<EiConjugate<Derived> > adjoint() const { return conjugate().transpose(); }
+    Row<Derived> row(int i);
+    Column<Derived> col(int i);
+    Minor<Derived> minor(int row, int col);
+    Block<Derived> block(int startRow, int endRow, int startCol, int endCol);
+    Transpose<Derived> transpose();
+    Conjugate<Derived> conjugate() const;
+    Transpose<Conjugate<Derived> > adjoint() const { return conjugate().transpose(); }
     Scalar trace() const;
     
     template<typename OtherDerived>
@@ -95,9 +95,9 @@ template<typename Scalar, typename Derived> class EiObject
     
     RealScalar norm2() const;
     RealScalar norm()  const;
-    EiScalarProduct<Derived> normalized() const;
+    ScalarProduct<Derived> normalized() const;
     
-    static EiEval<EiRandom<Derived> >
+    static Eval<Random<Derived> >
     random(int rows = RowsAtCompileTime, int cols = ColsAtCompileTime);
     
     template<typename OtherDerived>
@@ -106,15 +106,15 @@ template<typename Scalar, typename Derived> class EiObject
     bool isNegligible(const OtherDerived& other) const;
     
     template<typename OtherDerived>
-    EiMatrixProduct<Derived, OtherDerived>
-    lazyMul(const EiObject<Scalar, OtherDerived>& other) const EI_ALWAYS_INLINE;
+    MatrixProduct<Derived, OtherDerived>
+    lazyMul(const Object<Scalar, OtherDerived>& other) const EI_ALWAYS_INLINE;
     
     template<typename OtherDerived>
-    Derived& operator+=(const EiObject<Scalar, OtherDerived>& other);
+    Derived& operator+=(const Object<Scalar, OtherDerived>& other);
     template<typename OtherDerived>
-    Derived& operator-=(const EiObject<Scalar, OtherDerived>& other);
+    Derived& operator-=(const Object<Scalar, OtherDerived>& other);
     template<typename OtherDerived>
-    Derived& operator*=(const EiObject<Scalar, OtherDerived>& other);
+    Derived& operator*=(const Object<Scalar, OtherDerived>& other);
    
     Derived& operator*=(const int& other);
     Derived& operator*=(const float& other);
@@ -150,13 +150,13 @@ template<typename Scalar, typename Derived> class EiObject
       else return write(index, 0);
     }
     
-    EiEval<Derived> eval() const EI_ALWAYS_INLINE;
+    Eval<Derived> eval() const EI_ALWAYS_INLINE;
 };
 
 template<typename Scalar, typename Derived>
 std::ostream & operator <<
 ( std::ostream & s,
-  const EiObject<Scalar, Derived> & m )
+  const Object<Scalar, Derived> & m )
 {
   for( int i = 0; i < m.rows(); i++ )
   {
diff --git a/src/Core/Random.h b/src/Core/Random.h
index 70485028f..ff3f8b418 100644
--- a/src/Core/Random.h
+++ b/src/Core/Random.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,24 +26,24 @@
 #ifndef EI_RANDOM_H
 #define EI_RANDOM_H
 
-template<typename MatrixType> class EiRandom
-  : public EiObject<typename MatrixType::Scalar, EiRandom<MatrixType> >
+template<typename MatrixType> class Random
+  : public Object<typename MatrixType::Scalar, Random<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
-    friend class EiObject<Scalar, EiRandom<MatrixType> >;
+    friend class Object<Scalar, Random<MatrixType> >;
     
     static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
                      ColsAtCompileTime = MatrixType::ColsAtCompileTime;
 
-    EiRandom(int rows, int cols) : m_rows(rows), m_cols(cols)
+    Random(int rows, int cols) : m_rows(rows), m_cols(cols)
     {
       assert(rows > 0 && cols > 0);
     }
     
   private:
-    EiRandom& _ref() { return *this; }
-    const EiRandom& _constRef() const { return *this; }
+    Random& _ref() { return *this; }
+    const Random& _constRef() const { return *this; }
     int _rows() const { return m_rows; }
     int _cols() const { return m_cols; }
     
@@ -51,7 +51,7 @@ template<typename MatrixType> class EiRandom
     {
       EI_UNUSED(row);
       EI_UNUSED(col);
-      return EiRand<Scalar>();
+      return Rand<Scalar>();
     }
     
   protected:
@@ -59,9 +59,9 @@ template<typename MatrixType> class EiRandom
 };
 
 template<typename Scalar, typename Derived>
-EiEval<EiRandom<Derived> > EiObject<Scalar, Derived>::random(int rows, int cols)
+Eval<Random<Derived> > Object<Scalar, Derived>::random(int rows, int cols)
 {
-  return EiRandom<Derived>(rows, cols).eval();
+  return Random<Derived>(rows, cols).eval();
 }
 
 #endif // EI_RANDOM_H
diff --git a/src/Core/Row.h b/src/Core/Row.h
index 39efc0b2b..1fe1cf7ca 100644
--- a/src/Core/Row.h
+++ b/src/Core/Row.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,37 +26,37 @@
 #ifndef EI_ROW_H
 #define EI_ROW_H
 
-template<typename MatrixType> class EiRow
-  : public EiObject<typename MatrixType::Scalar, EiRow<MatrixType> >
+template<typename MatrixType> class Row
+  : public Object<typename MatrixType::Scalar, Row<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Ref MatRef;
-    friend class EiObject<Scalar, EiRow<MatrixType> >;
+    friend class Object<Scalar, Row<MatrixType> >;
 
     static const int RowsAtCompileTime = 1,
                      ColsAtCompileTime = MatrixType::ColsAtCompileTime;
 
-    EiRow(const MatRef& matrix, int row)
+    Row(const MatRef& matrix, int row)
       : m_matrix(matrix), m_row(row)
     {
       EI_CHECK_ROW_RANGE(matrix, row);
     }
     
-    EiRow(const EiRow& other)
+    Row(const Row& other)
       : m_matrix(other.m_matrix), m_row(other.m_row) {}
     
     template<typename OtherDerived>
-    EiRow& operator=(const EiObject<Scalar, OtherDerived>& other)
+    Row& operator=(const Object<Scalar, OtherDerived>& other)
     {
-      return EiObject<Scalar, EiRow<MatrixType> >::operator=(other);
+      return Object<Scalar, Row<MatrixType> >::operator=(other);
     }
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiRow)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Row)
     
   private:
-    EiRow& _ref() { return *this; }
-    const EiRow& _constRef() const { return *this; }
+    Row& _ref() { return *this; }
+    const Row& _constRef() const { return *this; }
     
     int _rows() const { return 1; }
     int _cols() const { return m_matrix.cols(); }
@@ -79,10 +79,10 @@ template<typename MatrixType> class EiRow
 };
 
 template<typename Scalar, typename Derived>
-EiRow<Derived>
-EiObject<Scalar, Derived>::row(int i)
+Row<Derived>
+Object<Scalar, Derived>::row(int i)
 {
-  return EiRow<Derived>(static_cast<Derived*>(this)->ref(), i);
+  return Row<Derived>(static_cast<Derived*>(this)->ref(), i);
 }
 
 #endif // EI_ROW_H
diff --git a/src/Core/ScalarOps.h b/src/Core/ScalarOps.h
index c058978e6..dc0709687 100644
--- a/src/Core/ScalarOps.h
+++ b/src/Core/ScalarOps.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,28 +26,28 @@
 #ifndef EI_SCALAROPS_H
 #define EI_SCALAROPS_H
 
-template<typename MatrixType> class EiScalarProduct
-  : public EiObject<typename MatrixType::Scalar, EiScalarProduct<MatrixType> >
+template<typename MatrixType> class ScalarProduct
+  : public Object<typename MatrixType::Scalar, ScalarProduct<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::ConstRef MatRef;
-    friend class EiObject<typename MatrixType::Scalar, EiScalarProduct<MatrixType> >;
+    friend class Object<typename MatrixType::Scalar, ScalarProduct<MatrixType> >;
 
     static const int RowsAtCompileTime = MatrixType::RowsAtCompileTime,
                      ColsAtCompileTime = MatrixType::ColsAtCompileTime;
 
-    EiScalarProduct(const MatRef& matrix, Scalar scalar)
+    ScalarProduct(const MatRef& matrix, Scalar scalar)
       : m_matrix(matrix), m_scalar(scalar) {}
 
-    EiScalarProduct(const EiScalarProduct& other)
+    ScalarProduct(const ScalarProduct& other)
       : m_matrix(other.m_matrix), m_scalar(other.m_scalar) {}
 
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiScalarProduct)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(ScalarProduct)
 
   private:
-    const EiScalarProduct& _ref() const { return *this; }
-    const EiScalarProduct& _constRef() const { return *this; }
+    const ScalarProduct& _ref() const { return *this; }
+    const ScalarProduct& _constRef() const { return *this; }
     int _rows() const { return m_matrix.rows(); }
     int _cols() const { return m_matrix.cols(); }
 
@@ -63,40 +63,40 @@ template<typename MatrixType> class EiScalarProduct
 
 #define EI_MAKE_SCALAR_OPS(OtherScalar)                                \
 template<typename Scalar, typename Derived>                            \
-EiScalarProduct<Derived>                                               \
-operator*(const EiObject<Scalar, Derived>& matrix,                     \
+ScalarProduct<Derived>                                               \
+operator*(const Object<Scalar, Derived>& matrix,                     \
           OtherScalar scalar)                                          \
 {                                                                      \
-  return EiScalarProduct<Derived>(matrix.constRef(), scalar);          \
+  return ScalarProduct<Derived>(matrix.constRef(), scalar);          \
 }                                                                      \
                                                                        \
 template<typename Scalar, typename Derived>                            \
-EiScalarProduct<Derived>                                               \
+ScalarProduct<Derived>                                               \
 operator*(OtherScalar scalar,                                          \
-          const EiObject<Scalar, Derived>& matrix)                     \
+          const Object<Scalar, Derived>& matrix)                     \
 {                                                                      \
-  return EiScalarProduct<Derived>(matrix.constRef(), scalar);          \
+  return ScalarProduct<Derived>(matrix.constRef(), scalar);          \
 }                                                                      \
                                                                        \
 template<typename Scalar, typename Derived>                            \
-EiScalarProduct<Derived>                                               \
-operator/(const EiObject<Scalar, Derived>& matrix,                     \
+ScalarProduct<Derived>                                               \
+operator/(const Object<Scalar, Derived>& matrix,                     \
           OtherScalar scalar)                                          \
 {                                                                      \
-  assert(EiNumTraits<Scalar>::HasFloatingPoint);                       \
+  assert(NumTraits<Scalar>::HasFloatingPoint);                       \
   return matrix * (static_cast<Scalar>(1) / scalar);                   \
 }                                                                      \
                                                                        \
 template<typename Scalar, typename Derived>                            \
 Derived &                                                              \
-EiObject<Scalar, Derived>::operator*=(const OtherScalar &other)        \
+Object<Scalar, Derived>::operator*=(const OtherScalar &other)        \
 {                                                                      \
   return *this = *this * other;                                        \
 }                                                                      \
                                                                        \
 template<typename Scalar, typename Derived>                            \
 Derived &                                                              \
-EiObject<Scalar, Derived>::operator/=(const OtherScalar &other)        \
+Object<Scalar, Derived>::operator/=(const OtherScalar &other)        \
 {                                                                      \
   return *this = *this / other;                                        \
 }
diff --git a/src/Core/Trace.h b/src/Core/Trace.h
index 80c5dbed1..41394cffa 100644
--- a/src/Core/Trace.h
+++ b/src/Core/Trace.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,16 +26,16 @@
 #ifndef EI_TRACE_H
 #define EI_TRACE_H
 
-template<int Index, int Rows, typename Derived> struct EiTraceUnroller
+template<int Index, int Rows, typename Derived> struct TraceUnroller
 {
   static void run(const Derived &mat, typename Derived::Scalar &trace)
   {
-    EiTraceUnroller<Index-1, Rows, Derived>::run(mat, trace);
+    TraceUnroller<Index-1, Rows, Derived>::run(mat, trace);
     trace += mat(Index, Index);
   }
 };
 
-template<int Rows, typename Derived> struct EiTraceUnroller<0, Rows, Derived>
+template<int Rows, typename Derived> struct TraceUnroller<0, Rows, Derived>
 {
   static void run(const Derived &mat, typename Derived::Scalar &trace)
   {
@@ -43,7 +43,7 @@ template<int Rows, typename Derived> struct EiTraceUnroller<0, Rows, Derived>
   }
 };
 
-template<int Index, typename Derived> struct EiTraceUnroller<Index, EiDynamic, Derived>
+template<int Index, typename Derived> struct TraceUnroller<Index, Dynamic, Derived>
 {
   static void run(const Derived &mat, typename Derived::Scalar &trace)
   {
@@ -53,12 +53,12 @@ template<int Index, typename Derived> struct EiTraceUnroller<Index, EiDynamic, D
 };
 
 template<typename Scalar, typename Derived>
-Scalar EiObject<Scalar, Derived>::trace() const
+Scalar Object<Scalar, Derived>::trace() const
 {
   assert(rows() == cols());
   Scalar res;
-  if(RowsAtCompileTime != EiDynamic && RowsAtCompileTime <= 16)
-    EiTraceUnroller<RowsAtCompileTime-1, RowsAtCompileTime, Derived>
+  if(RowsAtCompileTime != Dynamic && RowsAtCompileTime <= 16)
+    TraceUnroller<RowsAtCompileTime-1, RowsAtCompileTime, Derived>
       ::run(*static_cast<const Derived*>(this), res);
   else
   {
diff --git a/src/Core/Transpose.h b/src/Core/Transpose.h
index 90a9b727c..81f1090dd 100644
--- a/src/Core/Transpose.h
+++ b/src/Core/Transpose.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,27 +26,27 @@
 #ifndef EI_TRANSPOSE_H
 #define EI_TRANSPOSE_H
 
-template<typename MatrixType> class EiTranspose
-  : public EiObject<typename MatrixType::Scalar, EiTranspose<MatrixType> >
+template<typename MatrixType> class Transpose
+  : public Object<typename MatrixType::Scalar, Transpose<MatrixType> >
 {
   public:
     typedef typename MatrixType::Scalar Scalar;
     typedef typename MatrixType::Ref MatRef;
-    friend class EiObject<Scalar, EiTranspose<MatrixType> >;
+    friend class Object<Scalar, Transpose<MatrixType> >;
     
     static const int RowsAtCompileTime = MatrixType::ColsAtCompileTime,
                      ColsAtCompileTime = MatrixType::RowsAtCompileTime;
 
-    EiTranspose(const MatRef& matrix) : m_matrix(matrix) {}
+    Transpose(const MatRef& matrix) : m_matrix(matrix) {}
     
-    EiTranspose(const EiTranspose& other)
+    Transpose(const Transpose& other)
       : m_matrix(other.m_matrix) {}
     
-    EI_INHERIT_ASSIGNMENT_OPERATORS(EiTranspose)
+    EI_INHERIT_ASSIGNMENT_OPERATORS(Transpose)
     
   private:
-    EiTranspose& _ref() { return *this; }
-    const EiTranspose& _constRef() const { return *this; }
+    Transpose& _ref() { return *this; }
+    const Transpose& _constRef() const { return *this; }
     int _rows() const { return m_matrix.cols(); }
     int _cols() const { return m_matrix.rows(); }
     
@@ -65,10 +65,10 @@ template<typename MatrixType> class EiTranspose
 };
 
 template<typename Scalar, typename Derived>
-EiTranspose<Derived>
-EiObject<Scalar, Derived>::transpose()
+Transpose<Derived>
+Object<Scalar, Derived>::transpose()
 {
-  return EiTranspose<Derived>(static_cast<Derived*>(this)->ref());
+  return Transpose<Derived>(static_cast<Derived*>(this)->ref());
 }
 
 #endif // EI_TRANSPOSE_H
diff --git a/src/Core/Util.h b/src/Core/Util.h
index 460eecb1a..6871758c2 100644
--- a/src/Core/Util.h
+++ b/src/Core/Util.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -26,12 +26,12 @@
 #ifndef EI_UTIL_H
 #define EI_UTIL_H
 
-#include <iostream>
-#include <complex>
-#include <cassert>
-
 #undef minor
 
+#define USING_EIGEN_DATA_TYPES \
+EI_USING_MATRIX_TYPEDEFS \
+using Eigen::Matrix;
+
 #define EI_UNUSED(x) (void)x
 #define EI_CHECK_RANGES(matrix, row, col) \
   assert(row >= 0 && row < (matrix).rows() && col >= 0 && col < (matrix).cols())
@@ -41,36 +41,36 @@
   assert(col >= 0 && col < (matrix).cols())
 
 //forward declarations
-template<typename _Scalar, int _Rows, int _Cols> class EiMatrix;
-template<typename MatrixType> class EiMatrixRef;
-template<typename MatrixType> class EiMatrixConstRef;
-template<typename MatrixType> class EiRow;
-template<typename MatrixType> class EiColumn;
-template<typename MatrixType> class EiMinor;
-template<typename MatrixType> class EiBlock;
-template<typename MatrixType> class EiTranspose;
-template<typename MatrixType> class EiConjugate;
-template<typename Lhs, typename Rhs> class EiSum;
-template<typename Lhs, typename Rhs> class EiDifference;
-template<typename Lhs, typename Rhs> class EiMatrixProduct;
-template<typename MatrixType> class EiScalarProduct;
-template<typename MatrixType> class EiRandom;
-template<typename ExpressionType> class EiEval;
+template<typename _Scalar, int _Rows, int _Cols> class Matrix;
+template<typename MatrixType> class MatrixRef;
+template<typename MatrixType> class MatrixConstRef;
+template<typename MatrixType> class Row;
+template<typename MatrixType> class Column;
+template<typename MatrixType> class Minor;
+template<typename MatrixType> class Block;
+template<typename MatrixType> class Transpose;
+template<typename MatrixType> class Conjugate;
+template<typename Lhs, typename Rhs> class Sum;
+template<typename Lhs, typename Rhs> class Difference;
+template<typename Lhs, typename Rhs> class MatrixProduct;
+template<typename MatrixType> class ScalarProduct;
+template<typename MatrixType> class Random;
+template<typename ExpressionType> class Eval;
 
-template<typename T> struct EiForwardDecl
+template<typename T> struct ForwardDecl
 {
   typedef T Ref;
   typedef T ConstRef;
 };
 
 template<typename _Scalar, int _Rows, int _Cols>
-struct EiForwardDecl<EiMatrix<_Scalar, _Rows, _Cols> >
+struct ForwardDecl<Matrix<_Scalar, _Rows, _Cols> >
 {
-  typedef EiMatrixRef<EiMatrix<_Scalar, _Rows, _Cols> > Ref;
-  typedef EiMatrixConstRef<EiMatrix<_Scalar, _Rows, _Cols> > ConstRef;
+  typedef MatrixRef<Matrix<_Scalar, _Rows, _Cols> > Ref;
+  typedef MatrixConstRef<Matrix<_Scalar, _Rows, _Cols> > ConstRef;
 };
 
-const int EiDynamic = -1;
+const int Dynamic = -1;
 
 #define EI_LOOP_UNROLLING_LIMIT 25
 
@@ -86,20 +86,20 @@ const int EiDynamic = -1;
 
 #define EI_INHERIT_ASSIGNMENT_OPERATOR(Derived, Op) \
 template<typename OtherScalar, typename OtherDerived> \
-Derived& operator Op(const EiObject<OtherScalar, OtherDerived>& other) \
+Derived& operator Op(const Object<OtherScalar, OtherDerived>& other) \
 { \
-  return EiObject<Scalar, Derived>::operator Op(other); \
+  return Object<Scalar, Derived>::operator Op(other); \
 } \
 Derived& operator Op(const Derived& other) \
 { \
-  return EiObject<Scalar, Derived>::operator Op(other); \
+  return Object<Scalar, Derived>::operator Op(other); \
 }
 
 #define EI_INHERIT_SCALAR_ASSIGNMENT_OPERATOR(Derived, Op) \
 template<typename Other> \
 Derived& operator Op(const Other& scalar) \
 { \
-  return EiObject<Scalar, Derived>::operator Op(scalar); \
+  return Object<Scalar, Derived>::operator Op(scalar); \
 }
 
 #define EI_INHERIT_ASSIGNMENT_OPERATORS(Derived) \
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 352daa291..58a088eb3 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -15,6 +15,6 @@ QT4_AUTOMOC(${test_SRCS})
 ADD_EXECUTABLE(test ${test_SRCS})
 TARGET_LINK_LIBRARIES(test ${QT_QTCORE_LIBRARY} ${QT_QTTEST_LIBRARY})
 
-ADD_TEST(Eigen test)
+ADD_TEST(gen test)
 
 ENDIF(BUILD_TESTS)
diff --git a/test/main.cpp b/test/main.cpp
index f5c758961..fa0348002 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -25,7 +25,7 @@
 
 #include "main.h"
 
-EigenTest::EigenTest()
+genTest::genTest()
 {
     unsigned int t = (unsigned int) time( NULL );
     qDebug() << "Initializing random number generator with seed"
@@ -33,5 +33,5 @@ EigenTest::EigenTest()
     srand(t);
 }
 
-QTEST_APPLESS_MAIN( EigenTest )
+QTEST_APPLESS_MAIN( genTest )
 #include "main.moc"
diff --git a/test/main.h b/test/main.h
index 05853481c..c5aa3c085 100644
--- a/test/main.h
+++ b/test/main.h
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -29,17 +29,19 @@
 #include <QtTest/QtTest>
 #include "../src/Core.h"
 
+USING_EIGEN_DATA_TYPES
+
 #include <cstdlib>
 #include <ctime>
 
 using namespace std;
 
-class EigenTest : public QObject
+class genTest : public QObject
 {
     Q_OBJECT
 
   public:
-    EigenTest();
+    genTest();
 
   private slots:
     void testVectorOps();
@@ -47,7 +49,7 @@ class EigenTest : public QObject
     void testMatrixManip();
 };
 
-template<typename T> inline typename EiNumTraits<T>::Real TestEpsilon();
+template<typename T> inline typename Eigen::NumTraits<T>::Real TestEpsilon();
 template<> inline int TestEpsilon<int>() { return 0; }
 template<> inline float TestEpsilon<float>() { return 1e-2f; }
 template<> inline double TestEpsilon<double>() { return 1e-4; }
@@ -57,21 +59,21 @@ template<> inline double TestEpsilon<std::complex<double> >() { return TestEpsil
 
 template<typename T> bool TestNegligible(const T& a, const T& b)
 {
-  return(EiAbs(a) <= EiAbs(b) * TestEpsilon<T>());
+  return(Abs(a) <= Abs(b) * TestEpsilon<T>());
 }
 
 template<typename T> bool TestApprox(const T& a, const T& b)
 {
-  if(EiNumTraits<T>::IsFloat)
-    return(EiAbs(a - b) <= std::min(EiAbs(a), EiAbs(b)) * TestEpsilon<T>());
+  if(Eigen::NumTraits<T>::IsFloat)
+    return(Abs(a - b) <= std::min(Abs(a), Abs(b)) * TestEpsilon<T>());
   else
     return(a == b);
 }
 
 template<typename T> bool TestLessThanOrApprox(const T& a, const T& b)
 {
-  if(EiNumTraits<T>::IsFloat)
-    return(a < b || EiApprox(a, b));
+  if(Eigen::NumTraits<T>::IsFloat)
+    return(a < b || Approx(a, b));
   else
     return(a <= b);
 }
diff --git a/test/matrixmanip.cpp b/test/matrixmanip.cpp
index dd1887c87..c8863d183 100644
--- a/test/matrixmanip.cpp
+++ b/test/matrixmanip.cpp
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -42,12 +42,12 @@ template<typename MatrixType> void matrixManip(const MatrixType& m)
   a.minor(i, j) -= a.block(1, rows-1, 1, cols-1).eval();
 }
 
-void EigenTest::testMatrixManip()
+void genTest::testMatrixManip()
 {
-  matrixManip(EiMatrix<int, 2, 3>());
-  matrixManip(EiMatrix<double, 3, 3>());
-  matrixManip(EiMatrix<complex<float>, 4,3>());
-  matrixManip(EiMatrixXi(2, 2));
-  matrixManip(EiMatrixXd(3, 5));
-  matrixManip(EiMatrixXcf(4, 4));
+  matrixManip(Matrix<int, 2, 3>());
+  matrixManip(Matrix<double, 3, 3>());
+  matrixManip(Matrix<complex<float>, 4,3>());
+  matrixManip(MatrixXi(2, 2));
+  matrixManip(MatrixXd(3, 5));
+  matrixManip(MatrixXcf(4, 4));
 }
diff --git a/test/matrixops.cpp b/test/matrixops.cpp
index 8dc1aad83..100dbeffb 100644
--- a/test/matrixops.cpp
+++ b/test/matrixops.cpp
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -59,16 +59,16 @@ template<typename MatrixType1,
   QVERIFY( (d * e).rows() == rows1 && (d * e).cols() == cols2 );
 }
 
-void EigenTest::testMatrixOps()
+void genTest::testMatrixOps()
 {
-  matrixOps(EiMatrix<float, 1, 1>(), EiMatrix<float, 1, 1>());
-  matrixOps(EiMatrix<int, 2, 3>(), EiMatrix<int, 3, 1>());
-  matrixOps(EiMatrix<double, 3, 3>(), EiMatrix<double, 3, 3>());
-  matrixOps(EiMatrix<complex<float>, 4,3>(), EiMatrix<complex<float>, 3,4>());
-  matrixOps(EiMatrixXf(1, 1), EiMatrixXf(1, 3));
-  matrixOps(EiMatrixXi(2, 2), EiMatrixXi(2, 2));
-  matrixOps(EiMatrixXd(3, 5), EiMatrixXd(5, 1));
-  matrixOps(EiMatrixXcf(4, 4), EiMatrixXcf(4, 4));
-  matrixOps(EiMatrixXd(3, 5), EiMatrix<double, 5, 1>());
-  matrixOps(EiMatrix4cf(), EiMatrixXcf(4, 4));
+  matrixOps(Matrix<float, 1, 1>(), Matrix<float, 1, 1>());
+  matrixOps(Matrix<int, 2, 3>(), Matrix<int, 3, 1>());
+  matrixOps(Matrix<double, 3, 3>(), Matrix<double, 3, 3>());
+  matrixOps(Matrix<complex<float>, 4,3>(), Matrix<complex<float>, 3,4>());
+  matrixOps(MatrixXf(1, 1), MatrixXf(1, 3));
+  matrixOps(MatrixXi(2, 2), MatrixXi(2, 2));
+  matrixOps(MatrixXd(3, 5), MatrixXd(5, 1));
+  matrixOps(MatrixXcf(4, 4), MatrixXcf(4, 4));
+  matrixOps(MatrixXd(3, 5), Matrix<double, 5, 1>());
+  matrixOps(Matrix4cf(), MatrixXcf(4, 4));
 }
diff --git a/test/vectorops.cpp b/test/vectorops.cpp
index 659e9b5c8..87195ac36 100644
--- a/test/vectorops.cpp
+++ b/test/vectorops.cpp
@@ -1,19 +1,19 @@
-// This file is part of Eigen, a lightweight C++ template library
-// for linear algebra. Eigen itself is part of the KDE project.
+// This file is part of gen, a lightweight C++ template library
+// for linear algebra. gen itself is part of the KDE project.
 //
 // Copyright (C) 2006-2007 Benoit Jacob <jacob@math.jussieu.fr>
 //
-// Eigen is free software; you can redistribute it and/or modify it under the
+// gen is free software; you can redistribute it and/or modify it under the
 // terms of the GNU General Public License as published by the Free Software
 // Foundation; either version 2 or (at your option) any later version.
 //
-// Eigen is distributed in the hope that it will be useful, but WITHOUT ANY
+// gen is distributed in the hope that it will be useful, but WITHOUT ANY
 // WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 // FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
 // details.
 //
 // You should have received a copy of the GNU General Public License along
-// with Eigen; if not, write to the Free Software Foundation, Inc., 51
+// with gen; if not, write to the Free Software Foundation, Inc., 51
 // Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 //
 // As a special exception, if other files instantiate templates or use macros
@@ -50,13 +50,13 @@ template<typename VectorType> void vectorOps(const VectorType& v)
   a += (a + a).eval();
 }
 
-void EigenTest::testVectorOps()
+void genTest::testVectorOps()
 {
-  vectorOps(EiVector2i());
-  vectorOps(EiVector3d());
-  vectorOps(EiVector4cf());
-  vectorOps(EiVectorXf(1));
-  vectorOps(EiVectorXi(2));
-  vectorOps(EiVectorXd(3));
-  vectorOps(EiVectorXcf(4));
+  vectorOps(Vector2i());
+  vectorOps(Vector3d());
+  vectorOps(Vector4cf());
+  vectorOps(VectorXf(1));
+  vectorOps(VectorXi(2));
+  vectorOps(VectorXd(3));
+  vectorOps(VectorXcf(4));
 }