diff --git a/Eigen/src/Core/BandMatrix.h b/Eigen/src/Core/BandMatrix.h
index 7a37b3624..2da463afc 100644
--- a/Eigen/src/Core/BandMatrix.h
+++ b/Eigen/src/Core/BandMatrix.h
@@ -103,12 +103,21 @@ class BandMatrix : public MultiplierBase<BandMatrix<_Scalar,Rows,Cols,Supers,Sub
     inline int subs() const { return m_subs.value(); }
 
     /** \returns a vector expression of the \a i -th column,
-      * only the meaningful part is returned  */
+      * only the meaningful part is returned.
+      * \warning the internal storage must be column major. */
     inline Block<DataType,Dynamic,1> col(int i)
     {
-      int j = i - (cols() - supers() + 1);
-      int start = std::max(0,subs() - i + 1);
-      return Block<DataType,Dynamic,1>(m_data, start, i, m_data.rows() - (j<0 ? start : j), 1);
+      EIGEN_STATIC_ASSERT((Options&RowMajor)==0,THIS_METHOD_IS_ONLY_FOR_COLUMN_MAJOR_MATRICES);
+      int start = 0;
+      int len = m_data.rows();
+      if (i<=supers())
+      {
+        start = supers()-i;
+        len = std::min(rows(),std::max(0,m_data.rows() - (supers()-i)));
+      }
+      else if (i>=rows()-subs())
+        len = std::max(0,m_data.rows() - (i + 1 - rows() + subs()));
+      return Block<DataType,Dynamic,1>(m_data, start, i, len, 1);
     }
 
     /** \returns a vector expression of the main diagonal */
@@ -164,7 +173,6 @@ class BandMatrix : public MultiplierBase<BandMatrix<_Scalar,Rows,Cols,Supers,Sub
 
     PlainMatrixType toDense() const
     {
-      std::cerr << m_data << "\n\n";
       PlainMatrixType res(rows(),cols());
       res.setZero();
       res.diagonal() = diagonal();
diff --git a/Eigen/src/Core/Block.h b/Eigen/src/Core/Block.h
index 382518696..ffe065e8b 100644
--- a/Eigen/src/Core/Block.h
+++ b/Eigen/src/Core/Block.h
@@ -124,7 +124,7 @@ template<typename MatrixType, int BlockRows, int BlockCols, int PacketAccess, in
     {
       EIGEN_STATIC_ASSERT(RowsAtCompileTime!=Dynamic && ColsAtCompileTime!=Dynamic,THIS_METHOD_IS_ONLY_FOR_FIXED_SIZE)
       ei_assert(startRow >= 0 && BlockRows >= 1 && startRow + BlockRows <= matrix.rows()
-          && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
+             && startCol >= 0 && BlockCols >= 1 && startCol + BlockCols <= matrix.cols());
     }
 
     /** Dynamic-size constructor
@@ -137,8 +137,8 @@ template<typename MatrixType, int BlockRows, int BlockCols, int PacketAccess, in
     {
       ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
           && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
-      ei_assert(startRow >= 0 && blockRows >= 1 && startRow + blockRows <= matrix.rows()
-          && startCol >= 0 && blockCols >= 1 && startCol + blockCols <= matrix.cols());
+      ei_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= matrix.rows()
+          && startCol >= 0 && blockCols >= 0 && startCol + blockCols <= matrix.cols());
     }
 
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Block)
@@ -265,8 +265,8 @@ class Block<MatrixType,BlockRows,BlockCols,PacketAccess,HasDirectAccess>
     {
       ei_assert((RowsAtCompileTime==Dynamic || RowsAtCompileTime==blockRows)
              && (ColsAtCompileTime==Dynamic || ColsAtCompileTime==blockCols));
-      ei_assert(startRow >= 0 && blockRows >= 1 && startRow + blockRows <= matrix.rows()
-             && startCol >= 0 && blockCols >= 1 && startCol + blockCols <= matrix.cols());
+      ei_assert(startRow >= 0 && blockRows >= 0 && startRow + blockRows <= matrix.rows()
+             && startCol >= 0 && blockCols >= 0 && startCol + blockCols <= matrix.cols());
     }
 
     inline int stride(void) const { return m_matrix.stride(); }
diff --git a/Eigen/src/Core/CwiseNullaryOp.h b/Eigen/src/Core/CwiseNullaryOp.h
index c109d7f54..804bc2e74 100644
--- a/Eigen/src/Core/CwiseNullaryOp.h
+++ b/Eigen/src/Core/CwiseNullaryOp.h
@@ -64,10 +64,10 @@ class CwiseNullaryOp : ei_no_assignment_operator,
     CwiseNullaryOp(int rows, int cols, const NullaryOp& func = NullaryOp())
       : m_rows(rows), m_cols(cols), m_functor(func)
     {
-      ei_assert(rows > 0
-          && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
-          && cols > 0
-          && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
+      ei_assert(rows >= 0
+            && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+            &&  cols >= 0
+            && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols));
     }
 
     EIGEN_STRONG_INLINE int rows() const { return m_rows.value(); }
diff --git a/Eigen/src/Core/Diagonal.h b/Eigen/src/Core/Diagonal.h
index 7373abe24..f2bc8566e 100644
--- a/Eigen/src/Core/Diagonal.h
+++ b/Eigen/src/Core/Diagonal.h
@@ -70,7 +70,7 @@ template<typename MatrixType, int Index> class Diagonal
     EIGEN_STRONG_INLINE int absIndex() const { return m_index.value()>0 ? m_index.value() : -m_index.value(); }
     EIGEN_STRONG_INLINE int rowOffset() const { return m_index.value()>0 ? 0 : -m_index.value(); }
     EIGEN_STRONG_INLINE int colOffset() const { return m_index.value()>0 ? m_index.value() : 0; }
-    
+
   public:
 
     EIGEN_GENERIC_PUBLIC_INTERFACE(Diagonal)
@@ -79,7 +79,9 @@ template<typename MatrixType, int Index> class Diagonal
 
     EIGEN_INHERIT_ASSIGNMENT_OPERATORS(Diagonal)
 
-    inline int rows() const{ return m_matrix.diagonalSize() - absIndex(); }
+    inline int rows() const
+    { return m_index.value()<0 ? std::min(m_matrix.cols(),m_matrix.rows()+m_index.value()) : std::min(m_matrix.rows(),m_matrix.cols()-m_index.value()); }
+
     inline int cols() const { return 1; }
 
     inline Scalar& coeffRef(int row, int)
diff --git a/Eigen/src/Core/MapBase.h b/Eigen/src/Core/MapBase.h
index eddb19b03..721f2d476 100644
--- a/Eigen/src/Core/MapBase.h
+++ b/Eigen/src/Core/MapBase.h
@@ -154,16 +154,16 @@ template<typename Derived> class MapBase
               m_cols(ColsAtCompileTime == Dynamic ? size : ColsAtCompileTime)
     {
       EIGEN_STATIC_ASSERT_VECTOR_ONLY(Derived)
-      ei_assert(size > 0 || data == 0);
-      ei_assert(SizeAtCompileTime == Dynamic || SizeAtCompileTime == size);
+      ei_assert(size >= 0);
+      ei_assert(data == 0 || SizeAtCompileTime == Dynamic || SizeAtCompileTime == size);
     }
 
     inline MapBase(const Scalar* data, int rows, int cols)
             : m_data(data), m_rows(rows), m_cols(cols)
     {
       ei_assert( (data == 0)
-              || (   rows > 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
-                  && cols > 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
+              || (   rows >= 0 && (RowsAtCompileTime == Dynamic || RowsAtCompileTime == rows)
+                  && cols >= 0 && (ColsAtCompileTime == Dynamic || ColsAtCompileTime == cols)));
     }
 
     Derived& operator=(const MapBase& other)
diff --git a/test/bandmatrix.cpp b/test/bandmatrix.cpp
index 69ab0ed1d..f677e7b85 100644
--- a/test/bandmatrix.cpp
+++ b/test/bandmatrix.cpp
@@ -24,15 +24,20 @@
 
 #include "main.h"
 
-template<typename MatrixType> void bandmatrix(MatrixType& m)
+template<typename MatrixType> void bandmatrix(const MatrixType& _m)
 {
   typedef typename MatrixType::Scalar Scalar;
   typedef typename NumTraits<Scalar>::Real RealScalar;
   typedef Matrix<Scalar,Dynamic,Dynamic> DenseMatrixType;
 
-  int size = m.rows();
+  int rows = _m.rows();
+  int cols = _m.cols();
+  int supers = _m.supers();
+  int subs = _m.subs();
 
-  DenseMatrixType dm1(size,size);
+  MatrixType m(rows,cols,supers,subs);
+
+  DenseMatrixType dm1(rows,cols);
   dm1.setZero();
 
   m.diagonal().setConstant(123);
@@ -47,15 +52,33 @@ template<typename MatrixType> void bandmatrix(MatrixType& m)
     m.diagonal(-i).setConstant(-i);
     dm1.diagonal(-i).setConstant(-i);
   }
-  std::cerr << m.toDense() << "\n\n" << dm1 << "\n\n";
+  //std::cerr << m.m_data << "\n\n" << m.toDense() << "\n\n" << dm1 << "\n\n\n\n";
+  VERIFY_IS_APPROX(dm1,m.toDense());
+
+  for (int i=0; i<cols; ++i)
+  {
+    m.col(i).setConstant(i+1);
+    dm1.col(i).setConstant(i+1);
+  }
+  int d = std::min(rows,cols);
+  int a = std::max(0,cols-d-supers);
+  int b = std::max(0,rows-d-subs);
+  if(a>0) dm1.block(0,d+supers,rows,a).setZero();
+  dm1.block(0,supers+1,cols-supers-1-a,cols-supers-1-a).template triangularView<UpperTriangular>().setZero();
+  dm1.block(subs+1,0,rows-subs-1-b,rows-subs-1-b).template triangularView<LowerTriangular>().setZero();
+  if(b>0) dm1.block(d+subs,0,b,cols).setZero();
+  //std::cerr << m.m_data << "\n\n" << m.toDense() << "\n\n" << dm1 << "\n\n";
   VERIFY_IS_APPROX(dm1,m.toDense());
 
 }
 
 void test_bandmatrix()
 {
-  for(int i = 0; i < g_repeat ; i++) {
-    BandMatrix<float,Dynamic,Dynamic,Dynamic> m(6,6,3,2);
-    CALL_SUBTEST( bandmatrix(m) );
+  for(int i = 0; i < 10*g_repeat ; i++) {
+    int rows = ei_random<int>(1,10);
+    int cols = ei_random<int>(1,10);
+    int sups = ei_random<int>(0,cols-1);
+    int subs = ei_random<int>(0,rows-1);
+    CALL_SUBTEST( bandmatrix(BandMatrix<float>(rows,cols,sups,subs)) );
   }
 }