* Much better, consistent error msgs when mixing different scalar types:

- in matrix-matrix product, static assert on the two scalar types to be the same.
- Similarly in CwiseBinaryOp. POTENTIALLY CONTROVERSIAL: we don't allow anymore binary
  ops to take two different scalar types. The functors that we defined take two args
  of the same type anyway; also we still allow the return type to be different.
  Again the reason is that different scalar types are incompatible with vectorization.
  Better have the user realize explicitly what mixing different numeric types costs him
  in terms of performance.
  See comment in CwiseBinaryOp constructor.
- This allowed to fix a little mistake in test/regression.cpp, mixing float and double
- Remove redundant semicolon (;) after static asserts

2 files changed, 10 insertions, 9 deletions

diff --git a/Eigen/src/Core/util/Constants.h b/Eigen/src/Core/util/Constants.h
index e83c9f74c..20b427df1 100644
--- a/Eigen/src/Core/util/Constants.h
+++ b/Eigen/src/Core/util/Constants.h
@@ -31,14 +31,14 @@
   *
   * Explanation for the choice of this value:
   * - It should be positive and larger than any reasonable compile-time-fixed number of rows or columns.
-  *   This means that it should be at least 128 or so.
+  *   This allows to simplify many compile-time conditions throughout Eigen.
   * - It should be smaller than the sqrt of INT_MAX. Indeed, we often multiply a number of rows with a number
   *   of columns in order to compute a number of coefficients. Even if we guard that with an "if" checking whether
   *   the values are Dynamic, we still get a compiler warning "integer overflow". So the only way to get around
   *   it would be a meta-selector. Doing this everywhere would reduce code readability and lenghten compilation times.
   *   Also, disabling compiler warnings for integer overflow, sounds like a bad idea.
   *
-  * If you wish to port Eigen to a platform where sizeof(int)==2, it is perfectly possible to set Dynamic to, say, 250.
+  * If you wish to port Eigen to a platform where sizeof(int)==2, it is perfectly possible to set Dynamic to, say, 100.
   */
 const int Dynamic = 10000;
 
diff --git a/Eigen/src/Core/util/StaticAssert.h b/Eigen/src/Core/util/StaticAssert.h
index 4f22cf5f2..44f0008be 100644
--- a/Eigen/src/Core/util/StaticAssert.h
+++ b/Eigen/src/Core/util/StaticAssert.h
@@ -60,23 +60,24 @@
         you_mixed_matrices_of_different_sizes,
         this_method_is_only_for_vectors_of_a_specific_size,
         this_method_is_only_for_matrices_of_a_specific_size,
-        you_did_a_programming_error,
+        you_made_a_programming_mistake,
         you_called_a_fixed_size_method_on_a_dynamic_size_matrix_or_vector,
         unaligned_load_and_store_operations_unimplemented_on_AltiVec,
-        scalar_type_must_be_floating_point,
-        default_writting_to_selfadjoint_not_supported,
-        writting_to_triangular_part_with_unit_diag_is_not_supported,
+        numeric_type_must_be_floating_point,
+        default_writing_to_selfadjoint_not_supported,
+        writing_to_triangular_part_with_unit_diagonal_is_not_supported,
         this_method_is_only_for_fixed_size,
         invalid_matrix_product,
         invalid_vector_vector_product__if_you_wanted_a_dot_or_coeff_wise_product_you_must_use_the_explicit_functions,
-        invalid_matrix_product__if_you_wanted_a_coeff_wise_product_you_must_use_the_explicit_function
+        invalid_matrix_product__if_you_wanted_a_coeff_wise_product_you_must_use_the_explicit_function,
+	you_mixed_different_numeric_types__you_need_to_use_the_cast_method_of_MatrixBase_to_cast_numeric_types_explicitly
       };
     };
 
     #define EIGEN_STATIC_ASSERT(CONDITION,MSG) \
       if (Eigen::ei_static_assert<CONDITION ? true : false>::MSG) {}
 
-  #endif // CXX0X
+  #endif // not CXX0X
 
 #else // EIGEN_NO_STATIC_ASSERT
 
@@ -121,7 +122,7 @@
     || int(TYPE1::ColsAtCompileTime)==Eigen::Dynamic \
     || int(TYPE0::ColsAtCompileTime)==int(TYPE1::ColsAtCompileTime)))
 
-// static assertion failing if the two matrix expression types are not compatible (same fixed-size or dynamic size)
+// static assertion failing if it is guaranteed at compile-time that the two matrix expression types have different sizes
 #define EIGEN_STATIC_ASSERT_SAME_MATRIX_SIZE(TYPE0,TYPE1) \
   EIGEN_STATIC_ASSERT( \
      EIGEN_PREDICATE_SAME_MATRIX_SIZE(TYPE0,TYPE1),\