Solve a big issue with data alignment and dynamic allocation:

* add a WithAlignedOperatorNew class with overloaded operator new
* make Matrix (and Quaternion, Transform, Hyperplane, etc.) use it
  if needed such that "*(new Vector4) = xpr" does not failed anymore.
* Please: make sure your classes having fixed size Eigen's vector
  or matrice attributes inherit WithAlignedOperatorNew
* add a ei_new_allocator STL memory allocator to use with STL containers.
  This allocator really calls operator new on your types (unlike GCC's
  new_allocator). Example:
  std::vector<Vector4f> data(10);
  will segfault if the vectorization is enabled, instead use:
  std::vector<Vector4f,ei_new_allocator<Vector4f> > data(10);
NOTE: you only have to worry if you deal with fixed-size matrix types
with "sizeof(matrix_type)%16==0"...

Eigen/src/Core/Matrix.h

@@ -98,6 +98,9 @@ struct ei_traits<Matrix<_Scalar, _Rows, _Cols, _StorageOrder, _MaxRows, _MaxCols
 template<typename _Scalar, int _Rows, int _Cols, int _StorageOrder, int _MaxRows, int _MaxCols>
 class Matrix
   : public MatrixBase<Matrix<_Scalar, _Rows, _Cols, _StorageOrder, _MaxRows, _MaxCols> >
+    #ifdef EIGEN_VECTORIZE
+    , public ei_with_aligned_operator_new<_Scalar,ei_size_at_compile_time<_Rows,_Cols>::ret>
+    #endif
 {
   public:
     EIGEN_GENERIC_PUBLIC_INTERFACE(Matrix)

Eigen/src/Core/util/Memory.h

@@ -106,4 +106,128 @@ inline static int ei_alignmentOffset(const Scalar* ptr, int maxOffset)
 # define ei_free_stack(PTR,TYPE,SIZE) delete[] PTR
 #endif
 
+/** \class WithAlignedOperatorNew
+  *
+  * \brief Enforces inherited classes to be 16 bytes aligned when dynamicalled allocated with operator new
+  *
+  * When Eigen's explicit vectorization is enabled, Eigen assumes that some fixed sizes types are aligned
+  * on a 16 bytes boundary. Such types include:
+  *  - Vector2d, Vector4f, Vector4i, Vector4d,
+  *  - Matrix2d, Matrix4f, Matrix4i, Matrix4d,
+  *  - etc.
+  * When objects are statically allocated, the compiler will automatically and always enforces 16 bytes
+  * alignment of the data. However some troubles might appear when data are dynamically allocated.
+  * Let's pick an example:
+  * \code
+  * struct Foo {
+  *   char dummy;
+  *   Vector4f some_vector;
+  * };
+  * Foo obj1;                           // static allocation
+  * obj1.some_vector = Vector4f(..);    // =>   OK
+  *
+  * Foo *pObj2 = new Foo;               // dynamic allocation
+  * pObj2->some_vector = Vector4f(..);  // =>  !! might segfault !!
+  * \endcode
+  * Here, the problem is that operator new is not aware of the compile time alignment requirement of the
+  * type Vector4f (and hence of the type Foo). Therefore "new Foo" does not necessarily returned a 16 bytes
+  * aligned pointer. The purpose of the class WithAlignedOperatorNew is exacly to overcome this issue, by
+  * overloading the operator new to return aligned data when the vectorization is enabled.
+  * Here is a similar safe example:
+  * \code
+  * struct Foo : WithAlignedOperatorNew {
+  *   char dummy;
+  *   Vector4f some_vector;
+  * };
+  * Foo obj1;                           // static allocation
+  * obj1.some_vector = Vector4f(..);    // =>   OK
+  *
+  * Foo *pObj2 = new Foo;               // dynamic allocation
+  * pObj2->some_vector = Vector4f(..);  // =>  SAFE !
+  * \endcode 
+  *
+  * \sa class ei_new_allocator
+  */
+struct WithAlignedOperatorNew
+{
+  #ifdef EIGEN_VECTORIZE
+
+  void *operator new(size_t size) throw()
+  {
+    void* ptr = 0;
+    if (posix_memalign(&ptr, 16, size)==0)
+      return ptr;
+    else
+      return 0;
+  }
+
+  void *operator new[](size_t size) throw()
+  {
+    void* ptr = 0;
+    if (posix_memalign(&ptr, 16, size)==0)
+      return ptr;
+    else
+      return 0;
+  }
+
+  void operator delete(void * ptr) { free(ptr); }
+  void operator delete[](void * ptr) { free(ptr); }
+  
+  #endif
+};
+
+template<typename T, int SizeAtCompileTime,
+         bool NeedsToAlign = (SizeAtCompileTime!=Dynamic) && ((sizeof(T)*SizeAtCompileTime)%16==0)>
+struct ei_with_aligned_operator_new : WithAlignedOperatorNew {};
+
+template<typename T, int SizeAtCompileTime>
+struct ei_with_aligned_operator_new<T,SizeAtCompileTime,false> {};
+
+/** \class ei_new_allocator
+  *
+  * \brief stl compatible allocator to use with with fixed-size vector and matrix types
+  *
+  * STL allocator simply wrapping operators new[] and delete[]. Unlike GCC's default new_allocator,
+  * ei_new_allocator call operator new on the type \a T and not the general new operator ignoring
+  * overloaded version of operator new.
+  * 
+  * Example:
+  * \code
+  * // Vector4f requires 16 bytes alignment:
+  * std::vector<Vector4f,ei_new_allocator<Vector4f> > dataVec4;
+  * // Vector3f does not require 16 bytes alignment, no need to use Eigen's allocator:
+  * std::vector<Vector3f> dataVec3;
+  * 
+  * struct Foo : WithAlignedOperatorNew {
+  *   char dummy;
+  *   Vector4f some_vector;
+  * };
+  * std::vector<Foo,ei_new_allocator<Foo> > dataFoo;
+  * \endcode
+  *
+  * \sa class WithAlignedOperatorNew
+  */
+template<typename T> class ei_new_allocator
+{
+  public:
+    typedef T         value_type;
+    typedef T*        pointer;
+    typedef const T*  const_pointer;
+    typedef T&        reference;
+    typedef const T&  const_reference;
+
+    template<typename OtherType>
+    struct rebind
+    { typedef ei_new_allocator<OtherType> other; };
+
+    T* address(T& ref) const { return &ref; }
+    const T* address(const T& ref) const { return &ref; }
+    T* allocate(size_t size, const void* = 0) { return new T[size]; }
+    void deallocate(T* ptr, size_t) { delete[] ptr; }
+    size_t max_size() const { return size_t(-1) / sizeof(T); }
+    // FIXME I'm note sure about this construction...
+    void construct(T* ptr, const T& refObj) { ::new(ptr) T(refObj); }
+    void destroy(T* ptr) { ptr->~T(); }
+};
+
 #endif // EIGEN_MEMORY_H

Eigen/src/Geometry/Hyperplane.h

@@ -38,6 +38,9 @@
   */
 template <typename _Scalar, int _AmbientDim>
 class ParametrizedLine
+  #ifdef EIGEN_VECTORIZE
+  : public ei_with_aligned_operator_new<_Scalar,_AmbientDim>
+  #endif
 {
   public:
 
@@ -84,6 +87,9 @@ class ParametrizedLine
   */
 template <typename _Scalar, int _AmbientDim>
 class Hyperplane
+  #ifdef EIGEN_VECTORIZE
+  : public ei_with_aligned_operator_new<_Scalar,_AmbientDim==Dynamic ? Dynamic : _AmbientDim+1>
+  #endif
 {
   public:
 

Eigen/src/Geometry/Quaternion.h

@@ -59,6 +59,9 @@ template<typename _Scalar> struct ei_traits<Quaternion<_Scalar> >
 
 template<typename _Scalar>
 class Quaternion : public RotationBase<Quaternion<_Scalar>,3>
+  #ifdef EIGEN_VECTORIZE
+  , public ei_with_aligned_operator_new<_Scalar,4>
+  #endif
 {
   typedef RotationBase<Quaternion<_Scalar>,3> Base;
   typedef Matrix<_Scalar, 4, 1> Coefficients;

Eigen/src/Geometry/Scaling.h

@@ -41,6 +41,9 @@
   */
 template<typename _Scalar, int _Dim>
 class Scaling
+  #ifdef EIGEN_VECTORIZE
+  : public ei_with_aligned_operator_new<_Scalar,_Dim>
+  #endif
 {
 public:
   /** dimension of the space */

Eigen/src/Geometry/Transform.h

@@ -61,6 +61,9 @@ struct ei_transform_product_impl;
   */
 template<typename _Scalar, int _Dim>
 class Transform
+  #ifdef EIGEN_VECTORIZE
+  : public ei_with_aligned_operator_new<_Scalar,_Dim==Dynamic ? Dynamic : (_Dim+1)*(_Dim+1)>
+  #endif
 {
 public:
 

Eigen/src/Geometry/Translation.h

@@ -41,6 +41,9 @@
   */
 template<typename _Scalar, int _Dim>
 class Translation
+  #ifdef EIGEN_VECTORIZE
+  : public ei_with_aligned_operator_new<_Scalar,_Dim>
+  #endif
 {
 public:
   /** dimension of the space */