Armadillo 12.8.2

Author: eddelbuettel

inst/include/armadillo_bits/Mat_meat.hpp

@@ -942,11 +942,19 @@ Mat<eT>::init(const std::initializer_list< std::initializer_list<eT> >& list)
 
   uword x_n_rows = uword(list.size());
   uword x_n_cols = 0;
+  uword x_n_elem = 0;
 
   auto it     = list.begin();
   auto it_end = list.end();
 
-  for(; it != it_end; ++it)  { x_n_cols = (std::max)(x_n_cols, uword((*it).size())); }
+  for(; it != it_end; ++it)
+    {
+    const uword x_n_cols_new = uword((*it).size());
+    
+    x_n_elem += x_n_cols_new;
+    
+    x_n_cols = (std::max)(x_n_cols, x_n_cols_new);
+    }
 
   Mat<eT>& t = (*this);
 
@@ -959,6 +967,9 @@ Mat<eT>::init(const std::initializer_list< std::initializer_list<eT> >& list)
     t.set_size(x_n_rows, x_n_cols);
     }
 
+  // if the inner lists have varying number of elements, treat missing elements as zeros 
+  if(t.n_elem != x_n_elem)  { t.zeros(); }
+  
   uword row_num = 0;
 
   auto row_it     = list.begin();
@@ -977,11 +988,6 @@ Mat<eT>::init(const std::initializer_list< std::initializer_list<eT> >& list)
       ++col_num;
       }
 
-    for(uword c=col_num; c < x_n_cols; ++c)
-      {
-      t.at(row_num, c) = eT(0);
-      }
-    
     ++row_num;
     }
   }
@@ -6796,21 +6802,10 @@ Mat<eT>::set_size(const uword new_n_elem)
   {
   arma_extra_debug_sigprint();
 
-  switch(vec_state)
-    {
-    case 0:
-      // fallthrough
-    case 1:
-      init_warm(new_n_elem, 1);
-      break;
-    
-    case 2:
-      init_warm(1, new_n_elem);
-      break;
-      
-    default:
-      ;
-    }
+  const uword new_n_rows = (vec_state == 2) ? uword(1         ) : uword(new_n_elem);
+  const uword new_n_cols = (vec_state == 2) ? uword(new_n_elem) : uword(1         );
+  
+  init_warm(new_n_rows, new_n_cols);
 
   return *this;
   }
@@ -6854,23 +6849,10 @@ Mat<eT>::resize(const uword new_n_elem)
   {
   arma_extra_debug_sigprint();
 
-  switch(vec_state)
-    {
-    case 0:
-      // fallthrough
-    case 1:
-      (*this).resize(new_n_elem, 1);
-      break;
-    
-    case 2:
-      (*this).resize(1, new_n_elem);
-      break;
-      
-    default:
-      ;
-    }
+  const uword new_n_rows = (vec_state == 2) ? uword(1         ) : uword(new_n_elem);
+  const uword new_n_cols = (vec_state == 2) ? uword(new_n_elem) : uword(1         );
 
-  return *this;
+  return (*this).resize(new_n_rows, new_n_cols);
   }
 
 

inst/include/armadillo_bits/SpMat_bones.hpp

@@ -139,7 +139,7 @@ class SpMat : public SpBase< eT, SpMat<eT> >
   template<typename T1> inline SpMat& operator*=(const Op<T1, op_diagmat>& expr);
   template<typename T1> inline SpMat& operator/=(const Op<T1, op_diagmat>& expr);
   template<typename T1> inline SpMat& operator%=(const Op<T1, op_diagmat>& expr);
-
+  
   //! explicit specification of sparse +/- scalar
   template<typename T1, typename op_type> inline explicit SpMat(const SpToDOp<T1, op_type>& expr);
 

inst/include/armadillo_bits/SpMat_meat.hpp

@@ -3701,21 +3701,14 @@ SpMat<eT>::copy_size(const Mat<eT2>& m)
 template<typename eT>
 inline
 SpMat<eT>&
-SpMat<eT>::set_size(const uword in_elem)
+SpMat<eT>::set_size(const uword new_n_elem)
   {
   arma_extra_debug_sigprint();
 
-  // If this is a row vector, we resize to a row vector.
-  if(vec_state == 2)
-    {
-    set_size(1, in_elem);
-    }
-  else
-    {
-    set_size(in_elem, 1);
-    }
+  const uword new_n_rows = (vec_state == 2) ? uword(1         ) : uword(new_n_elem);
+  const uword new_n_cols = (vec_state == 2) ? uword(new_n_elem) : uword(1         );
 
-  return *this;
+  return set_size(new_n_rows, new_n_cols);
   }
 
 
@@ -4115,20 +4108,14 @@ SpMat<eT>::zeros()
 template<typename eT>
 inline
 SpMat<eT>&
-SpMat<eT>::zeros(const uword in_elem)
+SpMat<eT>::zeros(const uword new_n_elem)
   {
   arma_extra_debug_sigprint();
 
-  if(vec_state == 2)
-    {
-    zeros(1, in_elem); // Row vector
-    }
-  else
-    {
-    zeros(in_elem, 1);
-    }
+  const uword new_n_rows = (vec_state == 2) ? uword(1         ) : uword(new_n_elem);
+  const uword new_n_cols = (vec_state == 2) ? uword(new_n_elem) : uword(1         );
 
-  return *this;
+  return zeros(new_n_rows, new_n_cols);
   }
 
 
@@ -4432,12 +4419,10 @@ SpMat<eT>::reset()
   {
   arma_extra_debug_sigprint();
 
-  switch(vec_state)
-    {
-    default:  init(0, 0); break;
-    case 1:   init(0, 1); break;
-    case 2:   init(1, 0); break;
-    }
+  const uword new_n_rows = (vec_state == 2) ? 1 : 0;
+  const uword new_n_cols = (vec_state == 1) ? 1 : 0;
+  
+  init(new_n_rows, new_n_cols);
   }
 
 

inst/include/armadillo_bits/arma_version.hpp

@@ -23,7 +23,7 @@
 
 #define ARMA_VERSION_MAJOR 12
 #define ARMA_VERSION_MINOR 8
-#define ARMA_VERSION_PATCH 1
+#define ARMA_VERSION_PATCH 2
 #define ARMA_VERSION_NAME  "Cortisol Injector"
 
 

inst/include/armadillo_bits/def_fftw3.hpp

@@ -16,31 +16,38 @@
 // ------------------------------------------------------------------------
 
 
-#if defined(ARMA_USE_FFTW3)
+#if defined(ARMA_USE_FFTW3) && !defined(FFTW3_H)
+
+
+// prefix for single precision: fftwf_
+// prefix for double precision: fftw_
+
+
+typedef void fftwf_complex;
+typedef void  fftw_complex;
+
+typedef void_ptr fftwf_plan;
+typedef void_ptr  fftw_plan;
 
 
 extern "C"
   {
-  // function prefix for single precision: fftwf_
-  // function prefix for double precision: fftw_
-  
-  
   // single precision (float)
 
-  void_ptr fftwf_plan_dft_1d(int N, void* input, void* output, int fftw3_sign, unsigned int fftw3_flags);
+  fftwf_plan fftwf_plan_dft_1d(int N, fftwf_complex* input, fftwf_complex* output, int fftw3_sign, unsigned int fftw3_flags);
 
-  void      fftwf_execute(void_ptr plan);
-  void fftwf_destroy_plan(void_ptr plan);
+  void      fftwf_execute(fftwf_plan plan);
+  void fftwf_destroy_plan(fftwf_plan plan);
 
   void fftwf_cleanup();
 
 
   // double precision (double)
 
-  void_ptr fftw_plan_dft_1d(int N, void* input, void* output, int fftw3_sign, unsigned int fftw3_flags);
+  fftw_plan fftw_plan_dft_1d(int N, fftw_complex* input, fftw_complex* output, int fftw3_sign, unsigned int fftw3_flags);
 
-  void      fftw_execute(void_ptr plan);
-  void fftw_destroy_plan(void_ptr plan);
+  void      fftw_execute(fftw_plan plan);
+  void fftw_destroy_plan(fftw_plan plan);
 
   void fftw_cleanup();
   }

inst/include/armadillo_bits/translate_fftw3.hpp

@@ -30,12 +30,12 @@ namespace fftw3
 
     if(is_cx_float<eT>::value)
       {
-      return fftwf_plan_dft_1d(N, (cx_float*)input, (cx_float*)output, fftw3_sign, fftw3_flags);
+      return fftwf_plan_dft_1d(N, (fftwf_complex*)(input), (fftwf_complex*)(output), fftw3_sign, fftw3_flags);
       }
     else
     if(is_cx_double<eT>::value)
       {
-      return fftw_plan_dft_1d(N, (cx_double*)input, (cx_double*)output, fftw3_sign, fftw3_flags);
+      return fftw_plan_dft_1d(N, (fftw_complex*)(input), (fftw_complex*)(output), fftw3_sign, fftw3_flags);
       }
 
     return nullptr;
@@ -52,12 +52,12 @@ namespace fftw3
 
     if(is_cx_float<eT>::value)
       {
-      fftwf_execute(plan);
+      fftwf_execute(fftwf_plan(plan));
       }
     else
     if(is_cx_double<eT>::value)
       {
-      fftw_execute(plan);
+      fftw_execute(fftw_plan(plan));
       }
     }
 
@@ -72,12 +72,12 @@ namespace fftw3
 
     if(is_cx_float<eT>::value)
       {
-      fftwf_destroy_plan(plan);
+      fftwf_destroy_plan(fftwf_plan(plan));
       }
     else
     if(is_cx_double<eT>::value)
       {
-      fftw_destroy_plan(plan);
+      fftw_destroy_plan(fftw_plan(plan));
       }
     }
 

inst/include/armadillo_bits/wall_clock_bones.hpp

@@ -34,9 +34,9 @@ class wall_clock
 
   private:
 
-  bool valid = false;
-  
   std::chrono::steady_clock::time_point chrono_time1;
+  
+  bool valid = false;
   };
 
 

inst/include/armadillo_bits/wall_clock_meat.hpp

@@ -24,6 +24,8 @@ inline
 wall_clock::wall_clock()
   {
   arma_extra_debug_sigprint();
+  
+  chrono_time1 = std::chrono::steady_clock::now();  // warmup
   }
 
 
@@ -43,6 +45,7 @@ wall_clock::tic()
   arma_extra_debug_sigprint();
 
   chrono_time1 = std::chrono::steady_clock::now();
+  
   valid = true;
   }
 
@@ -54,18 +57,13 @@ wall_clock::toc()
   {
   arma_extra_debug_sigprint();
 
-  if(valid)
-    {
-    const std::chrono::steady_clock::time_point chrono_time2 = std::chrono::steady_clock::now();
-    
-    typedef std::chrono::duration<double> duration_type;  // TODO: check this
-    
-    const duration_type chrono_span = std::chrono::duration_cast< duration_type >(chrono_time2 - chrono_time1);
-    
-    return chrono_span.count();
-    }
+  const std::chrono::steady_clock::time_point chrono_time2 = std::chrono::steady_clock::now();
+  
+  typedef std::chrono::duration<double> duration_type;  // TODO: check this
+  
+  const duration_type chrono_span = std::chrono::duration_cast< duration_type >(chrono_time2 - chrono_time1);
 
-  return 0.0;
+  return (valid) ? double(chrono_span.count()) : double(0);
   }