Updated / relaxed C++11 check

Author: eddelbuettel

inst/include/armadillo_bits/compiler_check.hpp

@@ -16,11 +16,16 @@
 // ------------------------------------------------------------------------
 
 
+#undef ARMA_HAVE_CXX11
 #undef ARMA_HAVE_CXX14
 #undef ARMA_HAVE_CXX17
 #undef ARMA_HAVE_CXX20
 #undef ARMA_HAVE_CXX23
 
+#if (__cplusplus >= 201103L)
+  #define ARMA_HAVE_CXX11
+#endif
+
 #if (__cplusplus >= 201402L)
   #define ARMA_HAVE_CXX14
 #endif
@@ -42,6 +47,9 @@
 #if defined(_MSVC_LANG)
 
   #if (_MSVC_LANG >= 201402L)
+    #undef  ARMA_HAVE_CXX11
+    #define ARMA_HAVE_CXX11
+    
     #undef  ARMA_HAVE_CXX14
     #define ARMA_HAVE_CXX14
   #endif
@@ -70,8 +78,15 @@
 #endif
 
 
-#if !defined(ARMA_HAVE_CXX14)
-  #error "*** C++14 compiler required; enable C++14 mode in your compiler, or use an earlier version of Armadillo"
+#if !defined(ARMA_HAVE_CXX11)
+  #error "*** C++11 compiler required; enable C++11 mode in your compiler, or use an earlier version of Armadillo"
+#endif
+
+
+#if (!defined(ARMA_HAVE_CXX14))
+  #if (!defined(ARMA_IGNORE_DEPRECATED_MARKER)) || defined(ARMA_DONT_IGNORE_DEPRECATED_MARKER) || defined(ARMA_DEBUG)
+    #pragma message ("INFO: support for C++11 is deprecated")
+  #endif
 #endif
 
 

inst/include/armadillo_bits/compiler_setup.hpp

@@ -34,8 +34,8 @@
 #define arma_aligned
 #define arma_align_mem
 #define arma_warn_unused
-#define arma_deprecated        [[deprecated]]
-#define arma_frown(msg)        [[deprecated(msg)]]
+#define arma_deprecated
+#define arma_frown(msg)
 #define arma_malloc
 #define arma_inline            inline
 #define arma_noinline
@@ -175,6 +175,8 @@
   #undef  arma_aligned
   #undef  arma_align_mem
   #undef  arma_warn_unused
+  #undef  arma_deprecated
+  #undef  arma_frown
   #undef  arma_malloc
   #undef  arma_inline
   #undef  arma_noinline
@@ -184,6 +186,8 @@
   #define arma_aligned     __attribute__((__aligned__))
   #define arma_align_mem   __attribute__((__aligned__(16)))
   #define arma_warn_unused __attribute__((__warn_unused_result__))
+  #define arma_deprecated  __attribute__((__deprecated__))
+  #define arma_frown(msg)  __attribute__((__deprecated__(msg)))
   #define arma_malloc      __attribute__((__malloc__))
   #define arma_inline      __attribute__((__always_inline__)) inline
   #define arma_noinline    __attribute__((__noinline__))
@@ -243,6 +247,16 @@
     #define arma_warn_unused __attribute__((__warn_unused_result__))
   #endif
 
+  #if __has_attribute(__deprecated__)
+    #undef  arma_deprecated
+    #define arma_deprecated __attribute__((__deprecated__))
+  #endif
+  
+  #if __has_attribute(__deprecated__)
+    #undef  arma_frown
+    #define arma_frown(msg) __attribute__((__deprecated__(msg)))
+  #endif
+  
   #if __has_attribute(__malloc__)
     #undef  arma_malloc
     #define arma_malloc __attribute__((__malloc__))
@@ -302,6 +316,8 @@
     #error "*** newer compiler required ***"
   #endif
 
+  #undef  arma_deprecated
+  #define arma_deprecated __declspec(deprecated)
   // #undef  arma_inline
   // #define arma_inline __forceinline inline
 
@@ -359,6 +375,15 @@
 #endif
 
 
+#if defined(ARMA_HAVE_CXX14)
+  #undef  arma_deprecated
+  #define arma_deprecated [[deprecated]]
+
+  #undef  arma_frown
+  #define arma_frown(msg) [[deprecated(msg)]]
+#endif
+
+
 #if defined(ARMA_HAVE_CXX17)
   #undef  arma_warn_unused
   #define arma_warn_unused  [[nodiscard]]

inst/include/armadillo_bits/debug.hpp

@@ -1420,6 +1420,7 @@ inline void arma_debug_check(bool state, const char* msg)  { arma_conform_check(
             << " (" << nickname << ')';
 
         out << "\n@ arma_config::wrapper            = " << arma_config::wrapper;
+        out << "\n@ arma_config::cxx14              = " << arma_config::cxx14;
         out << "\n@ arma_config::cxx17              = " << arma_config::cxx17;
         out << "\n@ arma_config::cxx20              = " << arma_config::cxx20;
         out << "\n@ arma_config::cxx23              = " << arma_config::cxx23;

inst/include/armadillo_bits/fn_accu.hpp

@@ -314,7 +314,7 @@ accu(const Glue<T1,T2,glue_times>& expr)
 
       arma_conform_assert_mul_size(PA.get_n_rows(), PA.get_n_cols(), PB.get_n_rows(), PB.get_n_cols(), "matrix multiplication");
 
-      return op_dot::apply_proxy(PA,PB);
+      return op_dot::apply_proxy_linear(PA,PB);
       }
     }
 
@@ -339,11 +339,42 @@ accu(const eGlue<T1,T2,eglue_schur>& expr)
   typedef typename expr_type::proxy1_type::stored_type P1_stored_type;
   typedef typename expr_type::proxy2_type::stored_type P2_stored_type;
 
+  constexpr bool is_sv = (is_subview<P1_stored_type>::value) || (is_subview<P2_stored_type>::value);
+  
+  if( (is_sv) && (expr.get_n_rows() >= 4) )
+    {
+    arma_debug_print("accu(): eglue_schur subview optimisation");
+    
+    typedef typename T1::elem_type eT;
+    
+    const sv_keep_unwrap<P1_stored_type>& UA(expr.P1.Q);
+    const sv_keep_unwrap<P2_stored_type>& UB(expr.P2.Q);
+    
+    typedef typename sv_keep_unwrap<T1>::stored_type UA_M_type;
+    typedef typename sv_keep_unwrap<T2>::stored_type UB_M_type;
+    
+    const UA_M_type& A = UA.M;
+    const UB_M_type& B = UB.M;
+    
+    // A and B have the same size (checked by the eGlue constructor)
+    
+    const uword A_n_rows = A.n_rows;
+    const uword A_n_cols = A.n_cols;
+    
+    eT acc = eT(0);
+    
+    for(uword c=0; c < A_n_cols; ++c)  { acc += op_dot::direct_dot(A_n_rows, A.colptr(c), B.colptr(c)); }
+    
+    return acc;
+    }
+  
   constexpr bool have_direct_mem_1 = (is_Mat<P1_stored_type>::value) || (is_subview_col<P1_stored_type>::value);
   constexpr bool have_direct_mem_2 = (is_Mat<P2_stored_type>::value) || (is_subview_col<P2_stored_type>::value);
 
   if(have_direct_mem_1 && have_direct_mem_2)
     {
+    arma_debug_print("accu(): eglue_schur direct_mem optimisation");
+    
     const quasi_unwrap<P1_stored_type> tmp1(expr.P1.Q);
     const quasi_unwrap<P2_stored_type> tmp2(expr.P2.Q);
 

inst/include/armadillo_bits/fn_as_scalar.hpp

@@ -117,7 +117,7 @@ as_scalar_redirect<2>::apply(const Glue<T1, T2, glue_times>& X)
       "as_scalar(): incompatible dimensions"
       );
 
-    return op_dot::apply_proxy(PA,PB);
+    return op_dot::apply_proxy_linear(PA,PB);
     }
   }
 

inst/include/armadillo_bits/op_dot_bones.hpp

@@ -57,10 +57,10 @@ class op_dot
   arma_hot inline static typename T1::elem_type apply(const T1& X, const T2& Y);
 
   template<typename T1, typename T2>
-  arma_hot inline static typename  arma_not_cx<typename T1::elem_type>::result apply_proxy(const Proxy<T1>& PA, const Proxy<T2>& PB);
+  arma_hot inline static typename  arma_not_cx<typename T1::elem_type>::result apply_proxy_linear(const Proxy<T1>& PA, const Proxy<T2>& PB);
 
   template<typename T1, typename T2>
-  arma_hot inline static typename arma_cx_only<typename T1::elem_type>::result apply_proxy(const Proxy<T1>& PA, const Proxy<T2>& PB);
+  arma_hot inline static typename arma_cx_only<typename T1::elem_type>::result apply_proxy_linear(const Proxy<T1>& PA, const Proxy<T2>& PB);
   };
 
 

inst/include/armadillo_bits/op_dot_meat.hpp

@@ -216,6 +216,8 @@ op_dot::apply(const T1& X, const T2& Y)
 
     if( (A.m.n_rows == 1) && (B.m.n_rows == 1) )
       {
+      arma_debug_print("op_dot::apply(): subview_row optimisation");
+      
       arma_conform_check( (A.n_elem != B.n_elem), "dot(): objects must have the same number of elements" );
 
       const eT* A_mem = A.m.memptr();
@@ -225,10 +227,47 @@ op_dot::apply(const T1& X, const T2& Y)
       }
     }
 
+  if(is_subview<T1>::value || is_subview<T2>::value)
+    {
+    arma_debug_print("op_dot::apply(): subview optimisation");
+    
+    const sv_keep_unwrap<T1>& UA(X);
+    const sv_keep_unwrap<T2>& UB(Y);
+    
+    typedef typename sv_keep_unwrap<T1>::stored_type UA_M_type;
+    typedef typename sv_keep_unwrap<T2>::stored_type UB_M_type;
+    
+    const UA_M_type& A = UA.M;
+    const UB_M_type& B = UB.M;
+    
+    const uword A_n_rows = A.n_rows;
+    const uword A_n_cols = A.n_cols;
+    
+    if( (A_n_rows == B.n_rows) && (A_n_cols == B.n_cols) )
+      {
+      eT acc = eT(0);
+      
+      for(uword c=0; c < A_n_cols; ++c)  { acc += op_dot::direct_dot(A_n_rows, A.colptr(c), B.colptr(c)); }
+      
+      return acc;
+      }
+    else
+      {
+      const quasi_unwrap<UA_M_type> UUA(A);
+      const quasi_unwrap<UB_M_type> UUB(B);
+      
+      arma_conform_check( (UUA.M.n_elem != UUB.M.n_elem), "dot(): objects must have the same number of elements" );
+      
+      return op_dot::direct_dot(UUA.M.n_elem, UUA.M.memptr(), UUB.M.memptr());
+      }
+    }
+  
   // if possible, bypass transposes of non-complex vectors
 
   if( (is_cx<eT>::no) && (resolves_to_vector<T1>::value) && (resolves_to_vector<T2>::value) && (partial_unwrap<T1>::is_fast) && (partial_unwrap<T2>::is_fast) )
     {
+    arma_debug_print("op_dot::apply(): vector optimisation");
+    
     const partial_unwrap<T1> UA(X);
     const partial_unwrap<T2> UB(Y);
 
@@ -250,6 +289,8 @@ op_dot::apply(const T1& X, const T2& Y)
 
   if(proxy_is_mat || use_at || have_direct_mem)
     {
+    arma_debug_print("op_dot::apply(): direct_mem optimisation");
+    
     const quasi_unwrap<T1> A(X);
     const quasi_unwrap<T2> B(Y);
 
@@ -263,15 +304,15 @@ op_dot::apply(const T1& X, const T2& Y)
 
   arma_conform_check( (PA.get_n_elem() != PB.get_n_elem()), "dot(): objects must have the same number of elements" );
 
-  return op_dot::apply_proxy(PA,PB);
+  return op_dot::apply_proxy_linear(PA,PB);
   }
 
 
 
 template<typename T1, typename T2>
 inline
 typename arma_not_cx<typename T1::elem_type>::result
-op_dot::apply_proxy(const Proxy<T1>& PA, const Proxy<T2>& PB)
+op_dot::apply_proxy_linear(const Proxy<T1>& PA, const Proxy<T2>& PB)
   {
   arma_debug_sigprint();
 
@@ -308,7 +349,7 @@ op_dot::apply_proxy(const Proxy<T1>& PA, const Proxy<T2>& PB)
 template<typename T1, typename T2>
 inline
 typename arma_cx_only<typename T1::elem_type>::result
-op_dot::apply_proxy(const Proxy<T1>& PA, const Proxy<T2>& PB)
+op_dot::apply_proxy_linear(const Proxy<T1>& PA, const Proxy<T2>& PB)
   {
   arma_debug_sigprint();