PR 572: Add initializer list constructors to Matrix and Array (include unit tests and doc)

- {1,2,3,4,5,...} for fixed-size vectors only
- {{1,2,3},{4,5,6}} for the general cases
- {{1,2,3,4,5,....}} is allowed for both row and column-vector

3 files changed, 167 insertions, 2 deletions

diff --git a/Eigen/src/Core/Array.h b/Eigen/src/Core/Array.h
index 16770fc7b..7ef37de7c 100644
--- a/Eigen/src/Core/Array.h
+++ b/Eigen/src/Core/Array.h
@@ -178,6 +178,20 @@ class Array
       Base::_check_template_params();
       this->template _init2<T0,T1>(val0, val1);
     }
+
+    #if EIGEN_HAS_CXX11
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Array(const std::initializer_list<T>& list,
+      typename internal::enable_if<internal::is_same<T, Scalar>::value, T>::type* = 0,
+      typename internal::enable_if<RowsAtCompileTime != Dynamic
+                                   && ColsAtCompileTime != Dynamic
+                                   && IsVectorAtCompileTime == 1, T>::type* = 0) : Base(list) {}
+
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const std::initializer_list<std::initializer_list<Scalar> >& list) : Base(list) {}
+    #endif // end EIGEN_HAS_CXX11
+
     #else
     /** \brief Constructs a fixed-sized array initialized with coefficients starting at \a data */
     EIGEN_DEVICE_FUNC explicit Array(const Scalar *data);
@@ -199,7 +213,39 @@ class Array
     Array(Index rows, Index cols);
     /** constructs an initialized 2D vector with given coefficients */
     Array(const Scalar& val0, const Scalar& val1);
-    #endif
+
+    /** \copydoc PlainObjectBase::PlainObjectBase(const std::initializer_list<Scalar>& list) 
+      *
+      * Example: \include Array_initializer_list2_cxx11.cpp
+      * Output: \verbinclude Array_initializer_list2_cxx11.out
+      *
+      * \sa Array::Array(const Scalar& val0, const Scalar& val1)
+      * \sa Array::Array(const Scalar& val0, const Scalar& val1, const Scalar& val2) */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Array(const std::initializer_list<Scalar>& list);
+
+    /**
+     * \brief Constructs an array and initializes it by elements given by an initializer list of initializer lists \cpp11
+     * 
+     * This constructor distinguishes between the construction of arbitrary array and arrays with one fixed dimension,
+     * 
+     * In the general case, the constructor takes an initializer list, representing the array rows, that contains for
+     * each row an initializer list, representing a single column, containing scalar values. Each of the inner
+     * initializer lists must contain the same number of elements. 
+     * 
+     * In the case of array with one fixed dimension, an initializer list containing just one other initializer list
+     * that contains the array elements can be passed. Therefore \c Array<int,\c Dynamic,\c 1>\c {{1,\c 2,\c 3,\c 4}} is
+     * legal and the more verbose syntax \c Array<int,\c Dynamic,\c 1>\c {{1},\c {2},\c {3},\c {4}} can be avoided.
+     * 
+     * \warning In the case of fixed-sized arrays, the initializer list size must be equal to the array \a rows rows
+     * and \a cols columns.
+     *  
+     * Example: \include Array_initializer_list_cxx11.cpp
+     * Output: \verbinclude Array_initializer_list_cxx11.out
+     */
+    EIGEN_DEVICE_FUNC
+    EIGEN_STRONG_INLINE Array(const std::initializer_list<std::initializer_list<Scalar> >& list);
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN 
 
     /** constructs an initialized 3D vector with given coefficients */
     EIGEN_DEVICE_FUNC
diff --git a/Eigen/src/Core/Matrix.h b/Eigen/src/Core/Matrix.h
index 7f4a7af93..5b375b41d 100644
--- a/Eigen/src/Core/Matrix.h
+++ b/Eigen/src/Core/Matrix.h
@@ -301,6 +301,20 @@ class Matrix
       Base::_check_template_params();
       Base::template _init2<T0,T1>(x, y);
     }
+
+    #if EIGEN_HAS_CXX11
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<T>& list,
+      typename internal::enable_if<internal::is_same<T, Scalar>::value, T>::type* = 0,
+      typename internal::enable_if<RowsAtCompileTime != Dynamic
+                                   && ColsAtCompileTime != Dynamic
+                                   && IsVectorAtCompileTime == 1, T>::type* = 0) : Base(list) {}
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<std::initializer_list<Scalar>>& list) : Base(list) {}
+    #endif // end EIGEN_HAS_CXX11
+
     #else
     /** \brief Constructs a fixed-sized matrix initialized with coefficients starting at \a data */
     EIGEN_DEVICE_FUNC
@@ -338,7 +352,41 @@ class Matrix
     
     /** \brief Constructs an initialized 2D vector with given coefficients */
     Matrix(const Scalar& x, const Scalar& y);
-    #endif
+
+    /** \copydoc PlainObjectBase::PlainObjectBase(const std::initializer_list<Scalar>& list)
+     *
+     * Example: \include Matrix_initializer_list2_cxx11.cpp
+     * Output: \verbinclude Matrix_initializer_list2_cxx11.out
+     *
+     * \sa Matrix::Matrix(const Scalar& x, const Scalar& y, const Scalar& z)
+     * \sa Matrix::Matrix(const Scalar& x, const Scalar& y, const Scalar& z, const Scalar& w) */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<Scalar>& list);
+
+    /**
+     * \brief Constructs a matrix and initializes it by elements given by an initializer list of initializer lists \cpp11
+     * 
+     * This constructor distinguishes between the construction of arbitrary matrices and matrices with one fixed dimension,
+     * i.e., vectors or rowvectors.
+     * 
+     * In the general case, the constructor takes an initializer list, representing the matrix rows, that contains for
+     * each row an initializer list, representing a single column, containing scalar values. Each of the inner
+     * initializer lists must contain the same number of elements. 
+     * 
+     * In the case of matrices with one fixed dimension, an initializer list containing just one other initializer list
+     * that contains the matrix elements can be passed. Therefore \c VectorXi\c {{1,\c 2,\c 3,\c 4}} is legal and the more
+     * verbose syntax \c VectorXi\c {{1},\c {2},\c {3},\c {4}} can be avoided.
+     * 
+     * \warning In the case of fixed-sized matrices, the initializer list size must be equal to the matrix \a rows rows
+     * and \a cols columns.
+     *  
+     * Example: \include Matrix_initializer_list_cxx11.cpp
+     * Output: \verbinclude Matrix_initializer_list_cxx11.out
+     */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE Matrix(const std::initializer_list<std::initializer_list<Scalar>>& list);
+
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN
 
     /** \brief Constructs an initialized 3D vector with given coefficients */
     EIGEN_DEVICE_FUNC
diff --git a/Eigen/src/Core/PlainObjectBase.h b/Eigen/src/Core/PlainObjectBase.h
index f551dabb0..1a996b0aa 100644
--- a/Eigen/src/Core/PlainObjectBase.h
+++ b/Eigen/src/Core/PlainObjectBase.h
@@ -526,6 +526,77 @@ class PlainObjectBase : public internal::dense_xpr_base<Derived>::type
 //       EIGEN_INITIALIZE_COEFFS_IF_THAT_OPTION_IS_ENABLED
     }
 
+    #ifdef EIGEN_PARSED_BY_DOXYGEN
+    /** 
+     * \brief Construct a vector with fixed number of rows or a rowvector with fixed number of 
+     * columns by passing an initializer list \cpp11
+     *
+     * \only_for_vectors
+     * 
+     * \warning To construct a vector or rowvector of fixed size, the number of values passed through
+     * the initializer list must match the the fixed number of rows in the vector case or
+     * the fixed number of columns in the rowvector case. */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<Scalar>& list);
+
+    /**
+     * \brief Constructs a Matrix or Array and initializes it by elements given by an initializer list of initializer
+     * lists \cpp11 */
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list);
+    #else // EIGEN_PARSED_BY_DOXYGEN
+    #if EIGEN_HAS_CXX11
+    template<typename T>
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<T>& list,
+      typename internal::enable_if<internal::is_same<T, Scalar>::value, T>::type* = 0,
+      typename internal::enable_if<RowsAtCompileTime != Dynamic
+                                   && ColsAtCompileTime != Dynamic
+                                   && IsVectorAtCompileTime ==  1, T>::type* = 0)
+      : m_storage()
+    {
+      _check_template_params();
+      EIGEN_STATIC_ASSERT_FIXED_SIZE(PlainObjectBase);
+      resize(list.size());
+      std::copy(list.begin(), list.end(), m_storage.data());
+    }
+
+    EIGEN_DEVICE_FUNC
+    explicit EIGEN_STRONG_INLINE PlainObjectBase(const std::initializer_list<std::initializer_list<Scalar>>& list)
+      : m_storage()
+    {
+      _check_template_params();
+
+      size_t list_size = 0;
+      if (list.begin() != list.end()) {
+        list_size = list.begin()->size();
+      }
+
+      // This is to allow syntax like VectorXi {{1, 2, 3, 4}}
+      if (ColsAtCompileTime == 1 && list.size() == 1) {
+        eigen_assert(list_size == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        resize(list_size, ColsAtCompileTime);
+        std::copy(list.begin()->begin(), list.begin()->end(), m_storage.data());
+      } else {
+        eigen_assert(list.size() == static_cast<size_t>(RowsAtCompileTime) || RowsAtCompileTime == Dynamic);
+        eigen_assert(list_size == static_cast<size_t>(ColsAtCompileTime) || ColsAtCompileTime == Dynamic);
+        resize(list.size(), list_size);
+       
+        Index row_index = 0;
+        for (const std::initializer_list<Scalar>& row : list) {
+          eigen_assert(list_size == row.size());
+          Index col_index = 0;
+          for (const Scalar& e : row) {
+            coeffRef(row_index, col_index) = e;
+            ++col_index;
+          }
+          ++row_index;
+        }
+      }
+    }
+    #endif  // end EIGEN_HAS_CXX11
+    #endif  // end EIGEN_PARSED_BY_DOXYGEN
+
     /** \sa PlainObjectBase::operator=(const EigenBase<OtherDerived>&) */
     template<typename OtherDerived>
     EIGEN_DEVICE_FUNC