Revert "Adds EIGEN_CONSTEXPR and EIGEN_NOEXCEPT to rows(), cols(), innerStride(), outerStride(), and size()"

This reverts commit 6cbb3038ac48cb5fe17eba4dfbf26e3e798041f1 because it
breaks clang-10 builds on x86 and aarch64 when C++11 is enabled.

1 files changed, 39 insertions, 27 deletions

diff --git a/Eigen/src/Core/Ref.h b/Eigen/src/Core/Ref.h
index c2a37eadb..9fca42873 100644
--- a/Eigen/src/Core/Ref.h
+++ b/Eigen/src/Core/Ref.h
@@ -10,7 +10,7 @@
 #ifndef EIGEN_REF_H
 #define EIGEN_REF_H
 
-namespace Eigen {
+namespace Eigen { 
 
 namespace internal {
 
@@ -48,7 +48,7 @@ struct traits<Ref<_PlainObjectType, _Options, _StrideType> >
     };
     typedef typename internal::conditional<MatchAtCompileTime,internal::true_type,internal::false_type>::type type;
   };
-
+  
 };
 
 template<typename Derived>
@@ -67,12 +67,12 @@ public:
   typedef MapBase<Derived> Base;
   EIGEN_DENSE_PUBLIC_INTERFACE(RefBase)
 
-  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index innerStride() const
+  EIGEN_DEVICE_FUNC inline Index innerStride() const
   {
     return StrideType::InnerStrideAtCompileTime != 0 ? m_stride.inner() : 1;
   }
 
-  EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR inline Index outerStride() const
+  EIGEN_DEVICE_FUNC inline Index outerStride() const
   {
     return StrideType::OuterStrideAtCompileTime != 0 ? m_stride.outer()
          : IsVectorAtCompileTime ? this->size()
@@ -86,7 +86,7 @@ public:
       m_stride(StrideType::OuterStrideAtCompileTime==Dynamic?0:StrideType::OuterStrideAtCompileTime,
                StrideType::InnerStrideAtCompileTime==Dynamic?0:StrideType::InnerStrideAtCompileTime)
   {}
-
+  
   EIGEN_INHERIT_ASSIGNMENT_OPERATORS(RefBase)
 
 protected:
@@ -94,13 +94,25 @@ protected:
   typedef Stride<StrideType::OuterStrideAtCompileTime,StrideType::InnerStrideAtCompileTime> StrideBase;
 
   // Resolves inner stride if default 0.
-  static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveInnerStride(Index inner) {
-    return inner == 0 ? 1 : inner;
+  static EIGEN_DEVICE_FUNC Index resolveInnerStride(Index inner) {
+    if (inner == 0) {
+      return 1;
+    }
+    return inner;
   }
-
+  
   // Resolves outer stride if default 0.
-  static EIGEN_DEVICE_FUNC EIGEN_CONSTEXPR Index resolveOuterStride(Index inner, Index outer, Index rows, Index cols, bool isVectorAtCompileTime, bool isRowMajor) {
-    return outer == 0 ? isVectorAtCompileTime ? inner * rows * cols : isRowMajor ? inner * cols : inner * rows : outer;
+  static EIGEN_DEVICE_FUNC Index resolveOuterStride(Index inner, Index outer, Index rows, Index cols, bool isVectorAtCompileTime, bool isRowMajor) {
+    if (outer == 0) {
+      if (isVectorAtCompileTime) {
+        outer = inner * rows * cols;
+      } else if (isRowMajor) {
+        outer = inner * cols;
+      } else {
+        outer = inner * rows;
+      }
+    }
+    return outer;
   }
 
   // Returns true if construction is valid, false if there is a stride mismatch,
@@ -143,8 +155,8 @@ protected:
       (PlainObjectType::RowsAtCompileTime == Dynamic) || (PlainObjectType::RowsAtCompileTime == rows));
     eigen_assert(
       (PlainObjectType::ColsAtCompileTime == Dynamic) || (PlainObjectType::ColsAtCompileTime == cols));
-
-
+  
+  
     // If this is a vector, we might be transposing, which means that stride should swap.
     const bool transpose = PlainObjectType::IsVectorAtCompileTime && (rows != expr.rows());
     // If the storage format differs, we also need to swap the stride.
@@ -153,42 +165,42 @@ protected:
     const bool storage_differs =  (row_major != expr_row_major);
 
     const bool swap_stride = (transpose != storage_differs);
-
+    
     // Determine expr's actual strides, resolving any defaults if zero.
     const Index expr_inner_actual = resolveInnerStride(expr.innerStride());
-    const Index expr_outer_actual = resolveOuterStride(expr_inner_actual,
+    const Index expr_outer_actual = resolveOuterStride(expr_inner_actual, 
                                                        expr.outerStride(),
                                                        expr.rows(),
-                                                       expr.cols(),
+                                                       expr.cols(), 
                                                        Expression::IsVectorAtCompileTime != 0,
                                                        expr_row_major);
-
+                                                       
     // If this is a column-major row vector or row-major column vector, the inner-stride
     // is arbitrary, so set it to either the compile-time inner stride or 1.
     const bool row_vector = (rows == 1);
     const bool col_vector = (cols == 1);
-    const Index inner_stride =
-        ( (!row_major && row_vector) || (row_major && col_vector) ) ?
-            ( StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1)
+    const Index inner_stride = 
+        ( (!row_major && row_vector) || (row_major && col_vector) ) ? 
+            ( StrideType::InnerStrideAtCompileTime > 0 ? Index(StrideType::InnerStrideAtCompileTime) : 1) 
             : swap_stride ? expr_outer_actual : expr_inner_actual;
-
+              
     // If this is a column-major column vector or row-major row vector, the outer-stride
     // is arbitrary, so set it to either the compile-time outer stride or vector size.
-    const Index outer_stride =
-      ( (!row_major && col_vector) || (row_major && row_vector) ) ?
-          ( StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime) : rows * cols * inner_stride)
+    const Index outer_stride = 
+      ( (!row_major && col_vector) || (row_major && row_vector) ) ? 
+          ( StrideType::OuterStrideAtCompileTime > 0 ? Index(StrideType::OuterStrideAtCompileTime) : rows * cols * inner_stride) 
           : swap_stride ? expr_inner_actual : expr_outer_actual;
-
+  
     // Check if given inner/outer strides are compatible with compile-time strides.
     const bool inner_valid = (StrideType::InnerStrideAtCompileTime == Dynamic)
         || (resolveInnerStride(Index(StrideType::InnerStrideAtCompileTime)) == inner_stride);
     if (!inner_valid) {
       return false;
     }
-
+    
     const bool outer_valid = (StrideType::OuterStrideAtCompileTime == Dynamic)
         || (resolveOuterStride(
-              inner_stride,
+              inner_stride, 
               Index(StrideType::OuterStrideAtCompileTime),
               rows, cols, PlainObjectType::IsVectorAtCompileTime != 0,
               row_major)
@@ -196,7 +208,7 @@ protected:
     if (!outer_valid) {
       return false;
     }
-
+    
     ::new (static_cast<Base*>(this)) Base(expr.data(), rows, cols);
     ::new (&m_stride) StrideBase(
       (StrideType::OuterStrideAtCompileTime == 0) ? 0 : outer_stride,