Armadillo 14.0.2

eddelbuettel · eddelbuettel · commit 37de525039c0 · 2024-08-06T06:53:54.000-05:00
diff --git a/inst/include/armadillo b/inst/include/armadillo
@@ -35,6 +35,7 @@
 #include <cmath>
 #include <ctime>
 
+#include <memory>
 #include <iostream>
 #include <fstream>
 #include <sstream>
@@ -52,7 +53,7 @@
 #include <chrono>
 #include <atomic>
 
-#if !defined(ARMA_DONT_USE_STD_MUTEX)
+#if defined(ARMA_USE_STD_MUTEX)
   #include <mutex>
 #endif
 
diff --git a/inst/include/armadillo_bits/Cube_meat.hpp b/inst/include/armadillo_bits/Cube_meat.hpp
@@ -3562,7 +3562,7 @@ Cube<eT>::operator() (const uword in_row, const uword in_col, const uword in_sli
   //! element accessor; no bounds check
   template<typename eT>
   arma_inline
-    eT&
+  eT&
   Cube<eT>::operator[] (const uword in_row, const uword in_col, const uword in_slice)
     {
     return access::rw( mem[in_slice*n_elem_slice + in_col*n_rows + in_row] );
@@ -3573,7 +3573,7 @@ Cube<eT>::operator() (const uword in_row, const uword in_col, const uword in_sli
   //! element accessor; no bounds check
   template<typename eT>
   arma_inline
-    const eT&
+  const eT&
   Cube<eT>::operator[] (const uword in_row, const uword in_col, const uword in_slice) const
     {
     return mem[in_slice*n_elem_slice + in_col*n_rows + in_row];
diff --git a/inst/include/armadillo_bits/Mat_meat.hpp b/inst/include/armadillo_bits/Mat_meat.hpp
@@ -6500,7 +6500,7 @@ Mat<eT>::at(const uword in_row, const uword in_col) const
   //! element accessor; no bounds check
   template<typename eT>
   arma_inline
-    eT&
+  eT&
   Mat<eT>::operator[] (const uword in_row, const uword in_col)
     {
     return access::rw( mem[in_row + in_col*n_rows] );
@@ -6511,7 +6511,7 @@ Mat<eT>::at(const uword in_row, const uword in_col) const
   //! element accessor; no bounds check
   template<typename eT>
   arma_inline
-    const eT&
+  const eT&
   Mat<eT>::operator[] (const uword in_row, const uword in_col) const
     {
     return mem[in_row + in_col*n_rows];
diff --git a/inst/include/armadillo_bits/Proxy.hpp b/inst/include/armadillo_bits/Proxy.hpp
@@ -795,7 +795,7 @@ struct Proxy< CubeToMatOp<T1, op_vectorise_cube_col> >
   
   static constexpr bool use_at      = false;
   static constexpr bool use_mp      = false;
-  static constexpr bool has_subview = false;
+  static constexpr bool has_subview = true;
   
   static constexpr bool is_row  = false;
   static constexpr bool is_col  = true;
@@ -891,7 +891,7 @@ struct Proxy< SpToDOp<SpMat<eT>, op_sp_nonzeros> >
   
   static constexpr bool use_at      = false;
   static constexpr bool use_mp      = false;
-  static constexpr bool has_subview = false;
+  static constexpr bool has_subview = true;
   
   static constexpr bool is_row  = false;
   static constexpr bool is_col  = true;
diff --git a/inst/include/armadillo_bits/SpMat_meat.hpp b/inst/include/armadillo_bits/SpMat_meat.hpp
@@ -3374,7 +3374,7 @@ SpMat<eT>::operator()(const uword i) const
   
   template<typename eT>
   arma_inline
-    SpMat_MapMat_val<eT>
+  SpMat_MapMat_val<eT>
   SpMat<eT>::operator[] (const uword in_row, const uword in_col)
     {
     return SpMat_MapMat_val<eT>((*this), cache, in_row, in_col);
@@ -3384,7 +3384,7 @@ SpMat<eT>::operator()(const uword i) const
   
   template<typename eT>
   arma_inline
-    eT
+  eT
   SpMat<eT>::operator[] (const uword in_row, const uword in_col) const
     {
     return get_value(in_row, in_col);
diff --git a/inst/include/armadillo_bits/arma_version.hpp b/inst/include/armadillo_bits/arma_version.hpp
@@ -23,7 +23,7 @@
 
 #define ARMA_VERSION_MAJOR 14
 #define ARMA_VERSION_MINOR 0
-#define ARMA_VERSION_PATCH 0
+#define ARMA_VERSION_PATCH 2
 #define ARMA_VERSION_NAME  "Stochastic Parrot"
 
 
diff --git a/inst/include/armadillo_bits/compiler_setup.hpp b/inst/include/armadillo_bits/compiler_setup.hpp
@@ -304,8 +304,6 @@
   #endif
   
   #undef  ARMA_HAVE_GCC_ASSUME_ALIGNED
-  #undef  ARMA_HAVE_ICC_ASSUME_ALIGNED
-  #define ARMA_HAVE_ICC_ASSUME_ALIGNED
   
 #endif
 
diff --git a/inst/include/armadillo_bits/config.hpp b/inst/include/armadillo_bits/config.hpp
@@ -349,18 +349,6 @@
   #define ARMA_WARN_LEVEL 3
 #endif
 
-#if defined(ARMA_DONT_PRINT_ERRORS)
-  #pragma message ("INFO: support for ARMA_DONT_PRINT_ERRORS option has been removed")
-  
-  #if defined(ARMA_PRINT_EXCEPTIONS)
-    #pragma message ("INFO: suggest to use ARMA_WARN_LEVEL and ARMA_DONT_PRINT_EXCEPTIONS options instead")
-  #else
-    #pragma message ("INFO: suggest to use ARMA_WARN_LEVEL option instead")
-  #endif
-  
-  #pragma message ("INFO: see the documentation for details")
-#endif
-
 #if defined(ARMA_DONT_PRINT_EXCEPTIONS)
   #undef ARMA_PRINT_EXCEPTIONS
 #endif
diff --git a/inst/include/armadillo_bits/diskio_meat.hpp b/inst/include/armadillo_bits/diskio_meat.hpp
@@ -1062,7 +1062,7 @@ diskio::save_coord_ascii(const Mat<eT>& x, std::ostream& f)
     f.put('\n');
     }
   
-  // make sure it's possible to figure out the matrix size later
+  // make sure it's possible to determine the matrix size
   if( (x.n_rows > 0) && (x.n_cols > 0) )
     {
     const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;
@@ -1125,7 +1125,7 @@ diskio::save_coord_ascii(const Mat< std::complex<T> >& x, std::ostream& f)
     f.put('\n');
     }
   
-  // make sure it's possible to figure out the matrix size later
+  // make sure it's possible to determine the matrix size
   if( (x.n_rows > 0) && (x.n_cols > 0) )
     {
     const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;
@@ -1319,8 +1319,8 @@ diskio::save_hdf5_binary(const Mat<eT>& x, const hdf5_name& spec, std::string& e
     hid_t dataspace = H5Screate_simple(2, dims, NULL);   // treat the matrix as a 2d array dataspace
     hid_t datatype  = hdf5_misc::get_hdf5_type<eT>();
     
-    // If this returned something invalid, well, it's time to crash.
-    arma_check(datatype == -1, "Mat::save(): unknown datatype for HDF5");
+    // fail if we can't handle the datatype
+    if(datatype == -1)  { err_msg = "unknown datatype for HDF5"; return false; }
     
     // MATLAB forces the users to specify a name at save time for HDF5;
     // Octave will use the default of 'dataset' unless otherwise specified.
@@ -3065,7 +3065,7 @@ diskio::save_coord_ascii(const SpMat<eT>& x, std::ostream& f)
     }
   
   
-  // make sure it's possible to figure out the matrix size later
+  // make sure it's possible to determine the matrix size
   if( (x.n_rows > 0) && (x.n_cols > 0) )
     {
     const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;
@@ -3128,7 +3128,7 @@ diskio::save_coord_ascii(const SpMat< std::complex<T> >& x, std::ostream& f)
     f.put('\n');
     }
   
-  // make sure it's possible to figure out the matrix size later
+  // make sure it's possible to determine the matrix size
   if( (x.n_rows > 0) && (x.n_cols > 0) )
     {
     const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;
@@ -4016,8 +4016,8 @@ diskio::save_hdf5_binary(const Cube<eT>& x, const hdf5_name& spec, std::string&
     hid_t dataspace = H5Screate_simple(3, dims, NULL);   // treat the cube as a 3d array dataspace
     hid_t datatype  = hdf5_misc::get_hdf5_type<eT>();
     
-    // If this returned something invalid, well, it's time to crash.
-    arma_check(datatype == -1, "Cube::save(): unknown datatype for HDF5");
+    // fail if we can't handle the datatype
+    if(datatype == -1)  { err_msg = "unknown datatype for HDF5"; return false; }
     
     // MATLAB forces the users to specify a name at save time for HDF5;
     // Octave will use the default of 'dataset' unless otherwise specified.
diff --git a/inst/include/armadillo_bits/field_meat.hpp b/inst/include/armadillo_bits/field_meat.hpp
@@ -614,7 +614,7 @@ field<oT>::operator() (const uword in_row, const uword in_col, const uword in_sl
   //! element accessor; no bounds check
   template<typename oT>
   arma_inline
-    oT&
+  oT&
   field<oT>::operator[] (const uword in_row, const uword in_col)
     {
     return (*mem[in_row + in_col*n_rows]);
@@ -625,7 +625,7 @@ field<oT>::operator() (const uword in_row, const uword in_col, const uword in_sl
   //! element accessor; no bounds check
   template<typename oT>
   arma_inline
-    const oT&
+  const oT&
   field<oT>::operator[] (const uword in_row, const uword in_col) const
     {
     return (*mem[in_row + in_col*n_rows]);
diff --git a/inst/include/armadillo_bits/fn_accu.hpp b/inst/include/armadillo_bits/fn_accu.hpp
@@ -272,59 +272,6 @@ accu(const T1& X)
 
 
 
-//! explicit handling of dot product expressed as matrix multiplication
-template<typename T1, typename T2>
-arma_warn_unused
-inline
-typename T1::elem_type
-accu(const Glue<T1,T2,glue_times>& expr)
-  {
-  arma_debug_sigprint();
-  
-  typedef typename T1::elem_type eT;
-  
-  if( (is_cx<eT>::no) && (resolves_to_rowvector<T1>::value && resolves_to_colvector<T2>::value) )
-    {
-    arma_debug_print("accu(): dot product optimisation");
-    
-    constexpr bool proxy_is_mat = (is_Mat<typename Proxy<T1>::stored_type>::value && is_Mat<typename Proxy<T2>::stored_type>::value);
-    
-    constexpr bool use_at = (Proxy<T1>::use_at) || (Proxy<T2>::use_at);
-    
-    constexpr bool fast_unwrap = (partial_unwrap<T1>::is_fast && partial_unwrap<T2>::is_fast);
-    
-    if(proxy_is_mat || use_at || fast_unwrap)
-      {
-      const partial_unwrap<T1> UA(expr.A);
-      const partial_unwrap<T2> UB(expr.B);
-      
-      const typename partial_unwrap<T1>::stored_type& A = UA.M;
-      const typename partial_unwrap<T2>::stored_type& B = UB.M;
-      
-      arma_conform_assert_mul_size(A, B, UA.do_trans, UB.do_trans, "matrix multiplication");
-      
-      const eT val = op_dot::direct_dot(A.n_elem, A.memptr(), B.memptr());
-      
-      return (UA.do_times || UB.do_times) ? (val * UA.get_val() * UB.get_val()) : val;
-      }
-    else
-      {
-      const Proxy<T1> PA(expr.A);
-      const Proxy<T2> PB(expr.B);
-      
-      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_linear(PA,PB);
-      }
-    }
-  
-  const Mat<eT> tmp(expr);
-  
-  return arrayops::accumulate( tmp.memptr(), tmp.n_elem );
-  }
-
-
-
 //! explicit handling of multiply-and-accumulate
 template<typename T1, typename T2>
 arma_warn_unused
diff --git a/inst/include/armadillo_bits/memory.hpp b/inst/include/armadillo_bits/memory.hpp
@@ -148,7 +148,7 @@ arma_inline
 bool
 memory::is_aligned(const eT* mem)
   {
-  #if (defined(ARMA_HAVE_ICC_ASSUME_ALIGNED) || defined(ARMA_HAVE_GCC_ASSUME_ALIGNED)) && !defined(ARMA_DONT_CHECK_ALIGNMENT)
+  #if (defined(ARMA_HAVE_GCC_ASSUME_ALIGNED) || defined(__cpp_lib_assume_aligned)) && !defined(ARMA_DONT_CHECK_ALIGNMENT)
     {
     return (sizeof(std::size_t) >= sizeof(eT*)) ? ((std::size_t(mem) & 0x0F) == 0) : false;
     }
@@ -168,33 +168,19 @@ arma_inline
 void
 memory::mark_as_aligned(eT*& mem)
   {
-  #if defined(ARMA_HAVE_ICC_ASSUME_ALIGNED)
+  #if defined(ARMA_HAVE_GCC_ASSUME_ALIGNED)
     {
-    __assume_aligned(mem, 16);
+    mem = (eT*)__builtin_assume_aligned(mem, 16);
     }
-  #elif defined(ARMA_HAVE_GCC_ASSUME_ALIGNED)
+  #elif defined(__cpp_lib_assume_aligned)
     {
-    mem = (eT*)__builtin_assume_aligned(mem, 16);
+    mem = (eT*)std::assume_aligned<16>(mem);
     }
   #else
     {
     arma_ignore(mem);
     }
   #endif
-  
-  // TODO: look into C++20 std::assume_aligned()
-  // TODO: https://en.cppreference.com/w/cpp/memory/assume_aligned
-  
-  // TODO: MSVC?  __assume( (mem & 0x0F) == 0 );
-  //
-  // http://comments.gmane.org/gmane.comp.gcc.patches/239430
-  // GCC __builtin_assume_aligned is similar to ICC's __assume_aligned,
-  // so for lvalue first argument ICC's __assume_aligned can be emulated using
-  // #define __assume_aligned(lvalueptr, align) lvalueptr = __builtin_assume_aligned (lvalueptr, align) 
-  //
-  // http://www.inf.ethz.ch/personal/markusp/teaching/263-2300-ETH-spring11/slides/class19.pdf
-  // http://software.intel.com/sites/products/documentation/hpc/composerxe/en-us/cpp/lin/index.htm
-  // http://d3f8ykwhia686p.cloudfront.net/1live/intel/CompilerAutovectorizationGuide.pdf
   }
 
 
@@ -204,13 +190,13 @@ arma_inline
 void
 memory::mark_as_aligned(const eT*& mem)
   {
-  #if defined(ARMA_HAVE_ICC_ASSUME_ALIGNED)
+  #if defined(ARMA_HAVE_GCC_ASSUME_ALIGNED)
     {
-    __assume_aligned(mem, 16);
+    mem = (const eT*)__builtin_assume_aligned(mem, 16);
     }
-  #elif defined(ARMA_HAVE_GCC_ASSUME_ALIGNED)
+  #elif defined(__cpp_lib_assume_aligned)
     {
-    mem = (const eT*)__builtin_assume_aligned(mem, 16);
+    mem = (const eT*)std::assume_aligned<16>(mem);
     }
   #else
     {
diff --git a/inst/include/armadillo_bits/mul_gemm.hpp b/inst/include/armadillo_bits/mul_gemm.hpp
@@ -316,8 +316,8 @@ class gemm
         
         const eT local_beta  = (use_beta) ? beta : eT(0);
         
-        arma_debug_print( arma_str::format("blas::gemm(): trans_A = %c") % trans_A );
-        arma_debug_print( arma_str::format("blas::gemm(): trans_B = %c") % trans_B );
+        arma_debug_print( arma_str::format("blas::gemm(): trans_A: %c") % trans_A );
+        arma_debug_print( arma_str::format("blas::gemm(): trans_B: %c") % trans_B );
         
         blas::gemm<eT>
           (
diff --git a/inst/include/armadillo_bits/mul_gemv.hpp b/inst/include/armadillo_bits/mul_gemv.hpp
@@ -378,7 +378,7 @@ class gemv
         const blas_int  inc         = blas_int(1);
         const eT        local_beta  = (use_beta) ? beta : eT(0);
         
-        arma_debug_print( arma_str::format("blas::gemv(): trans_A = %c") % trans_A );
+        arma_debug_print( arma_str::format("blas::gemv(): trans_A: %c") % trans_A );
         
         blas::gemv<eT>
           (
diff --git a/inst/include/armadillo_bits/mul_herk.hpp b/inst/include/armadillo_bits/mul_herk.hpp
@@ -405,7 +405,7 @@ class herk
         
         const blas_int lda = (do_trans_A) ? k : n;
         
-        arma_debug_print( arma_str::format("blas::herk(): trans_A = %c") % trans_A );
+        arma_debug_print( arma_str::format("blas::herk(): trans_A: %c") % trans_A );
         
         blas::herk<T>
           (
diff --git a/inst/include/armadillo_bits/mul_syrk.hpp b/inst/include/armadillo_bits/mul_syrk.hpp
@@ -362,7 +362,7 @@ class syrk
         
         const blas_int lda = (do_trans_A) ? k : n;
         
-        arma_debug_print( arma_str::format("blas::syrk(): trans_A = %c") % trans_A );
+        arma_debug_print( arma_str::format("blas::syrk(): trans_A: %c") % trans_A );
         
         blas::syrk<eT>
           (
diff --git a/inst/include/armadillo_bits/subview_field_meat.hpp b/inst/include/armadillo_bits/subview_field_meat.hpp
@@ -525,7 +525,7 @@ subview_field<oT>::extract(field<oT>& actual_out, const subview_field<oT>& in)
   
   out.set_size(n_rows, n_cols, n_slices);
   
-  arma_debug_print(arma_str::format("out.n_rows: %u; out.n_cols: %u; out.n_slices: %u; n.m.n_rows: %u; in.m.n_cols: %u; in.m.n_slices: %u") % out.n_rows % out.n_cols % out.n_slices % in.f.n_rows % in.f.n_cols % in.f.n_slices);
+  arma_debug_print(arma_str::format("out.n_rows: %u; out.n_cols: %u; out.n_slices: %u; in.f.n_rows: %u; in.f.n_cols: %u; in.f.n_slices: %u") % out.n_rows % out.n_cols % out.n_slices % in.f.n_rows % in.f.n_cols % in.f.n_slices);
   
   if(n_slices == 1)
     {
@@ -550,7 +550,6 @@ subview_field<oT>::extract(field<oT>& actual_out, const subview_field<oT>& in)
     actual_out = out;
     delete tmp;
     }
-  
   }
 
 
diff --git a/inst/include/armadillo_bits/subview_meat.hpp b/inst/include/armadillo_bits/subview_meat.hpp
diff --git a/inst/include/armadillo_bits/unwrap.hpp b/inst/include/armadillo_bits/unwrap.hpp

Original file line number	Diff line number	Diff line change
`@@ -1062,7 +1062,7 @@ diskio::save_coord_ascii(const Mat<eT>& x, std::ostream& f)`
`1062`	`1062`	`f.put('\n');`
`1063`	`1063`	`}`
`1064`	`1064`
`1065`		`- // make sure it's possible to figure out the matrix size later`
	`1065`	`+ // make sure it's possible to determine the matrix size`
`1066`	`1066`	`if( (x.n_rows > 0) && (x.n_cols > 0) )`
`1067`	`1067`	`{`
`1068`	`1068`	`const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;`
`@@ -1125,7 +1125,7 @@ diskio::save_coord_ascii(const Mat< std::complex<T> >& x, std::ostream& f)`
`1125`	`1125`	`f.put('\n');`
`1126`	`1126`	`}`
`1127`	`1127`
`1128`		`- // make sure it's possible to figure out the matrix size later`
	`1128`	`+ // make sure it's possible to determine the matrix size`
`1129`	`1129`	`if( (x.n_rows > 0) && (x.n_cols > 0) )`
`1130`	`1130`	`{`
`1131`	`1131`	`const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;`
`@@ -1319,8 +1319,8 @@ diskio::save_hdf5_binary(const Mat<eT>& x, const hdf5_name& spec, std::string& e`
`1319`	`1319`	`hid_t dataspace = H5Screate_simple(2, dims, NULL); // treat the matrix as a 2d array dataspace`
`1320`	`1320`	`hid_t datatype = hdf5_misc::get_hdf5_type<eT>();`
`1321`	`1321`
`1322`		`- // If this returned something invalid, well, it's time to crash.`
`1323`		`- arma_check(datatype == -1, "Mat::save(): unknown datatype for HDF5");`
	`1322`	`+ // fail if we can't handle the datatype`
	`1323`	`+ if(datatype == -1) { err_msg = "unknown datatype for HDF5"; return false; }`
`1324`	`1324`
`1325`	`1325`	`// MATLAB forces the users to specify a name at save time for HDF5;`
`1326`	`1326`	`// Octave will use the default of 'dataset' unless otherwise specified.`
`@@ -3065,7 +3065,7 @@ diskio::save_coord_ascii(const SpMat<eT>& x, std::ostream& f)`
`3065`	`3065`	`}`
`3066`	`3066`
`3067`	`3067`
`3068`		`- // make sure it's possible to figure out the matrix size later`
	`3068`	`+ // make sure it's possible to determine the matrix size`
`3069`	`3069`	`if( (x.n_rows > 0) && (x.n_cols > 0) )`
`3070`	`3070`	`{`
`3071`	`3071`	`const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;`
`@@ -3128,7 +3128,7 @@ diskio::save_coord_ascii(const SpMat< std::complex<T> >& x, std::ostream& f)`
`3128`	`3128`	`f.put('\n');`
`3129`	`3129`	`}`
`3130`	`3130`
`3131`		`- // make sure it's possible to figure out the matrix size later`
	`3131`	`+ // make sure it's possible to determine the matrix size`
`3132`	`3132`	`if( (x.n_rows > 0) && (x.n_cols > 0) )`
`3133`	`3133`	`{`
`3134`	`3134`	`const uword max_row = (x.n_rows > 0) ? x.n_rows-1 : 0;`
`@@ -4016,8 +4016,8 @@ diskio::save_hdf5_binary(const Cube<eT>& x, const hdf5_name& spec, std::string&`
`4016`	`4016`	`hid_t dataspace = H5Screate_simple(3, dims, NULL); // treat the cube as a 3d array dataspace`
`4017`	`4017`	`hid_t datatype = hdf5_misc::get_hdf5_type<eT>();`
`4018`	`4018`
`4019`		`- // If this returned something invalid, well, it's time to crash.`
`4020`		`- arma_check(datatype == -1, "Cube::save(): unknown datatype for HDF5");`
	`4019`	`+ // fail if we can't handle the datatype`
	`4020`	`+ if(datatype == -1) { err_msg = "unknown datatype for HDF5"; return false; }`
`4021`	`4021`
`4022`	`4022`	`// MATLAB forces the users to specify a name at save time for HDF5;`
`4023`	`4023`	`// Octave will use the default of 'dataset' unless otherwise specified.`