Merge branch '14.2.x' into '14.2.x'

arma_ignore Xst backport

See merge request conradsnicta/armadillo-code!147

docs.html

@@ -8210,18 +8210,13 @@ sp_mat A = sprandu<sp_mat>(100, 200, 0.1);
 <a name="toeplitz"></a>
 <b>toeplitz( A )</b>
 <br><b>toeplitz( A, B )</b>
-<br><b>circ_toeplitz( A )</b>
 <ul>
 <li>
-toeplitz(): generate a Toeplitz matrix, with the first column specified by <i>A</i>, and (optionally) the first row specified by <i>B</i>
+Generate a Toeplitz matrix, with the first column specified by vector <i>A</i>, and (optionally) the first row specified by vector <i>B</i>
 </li>
 <br>
 <li>
-circ_toeplitz(): generate a circulant Toeplitz matrix
-</li>
-<br>
-<li>
-A and B must be vectors
+If argument <i>B</i> is omitted, the first row is assumed to be the same as the first column
 </li>
 <br>
 <li>
@@ -8229,8 +8224,8 @@ Examples:
 <ul>
 <pre>
 vec A(5, fill::randu);
+
 mat X = toeplitz(A);
-mat Y = circ_toeplitz(A);
 </pre>
 </ul>
 </li>
@@ -8239,7 +8234,6 @@ mat Y = circ_toeplitz(A);
 <ul>
 <li><a href="https://mathworld.wolfram.com/ToeplitzMatrix.html">Toeplitz matrix in MathWorld</a></li>
 <li><a href="https://en.wikipedia.org/wiki/Toeplitz_matrix">Toeplitz matrix in Wikipedia</a></li>
-<li><a href="https://en.wikipedia.org/wiki/Circulant_matrix">Circulant matrix in Wikipedia</a></li>
 </ul>
 </li>
 <br>
@@ -12611,7 +12605,7 @@ For single argument functions, <i>B = trig_fn(A)</i>, where <i>trig_fn</i> is ap
 <i>tan</i>, <i>atan</i>, <i>tanh</i>, <i>atanh</i>
 </li>
 <li>
-<i>sinc</i>, defined as sinc(x) = sin(&pi;x)&thinsp;/&thinsp;(&pi;x) for x&thinsp;&ne;&thinsp;0, and sinc(x)&thinsp;=&thinsp;1 for x&thinsp;=&thinsp;0
+<i>sinc</i>, defined as sinc(x) = sin(&pi;&middot;x)&thinsp;/&thinsp;(&pi;&middot;x) for x&thinsp;&ne;&thinsp;0, and sinc(x)&thinsp;=&thinsp;1 for x&thinsp;=&thinsp;0
 </li>
 </ul>
 </li>
@@ -21088,7 +21082,7 @@ the <i>uword</i> type then has a minimum width of 64 bits
 <li>Version 2.2:
 <ul>
 <li>added <a href="#svd_econ">svd_econ()</a></li>
-<li>added <a href="#toeplitz">circ_toeplitz()</a></li>
+<!-- <li>added <a href="#toeplitz">circ_toeplitz()</a></li> -->
 <li>added <a href="#is_vec">.is_colvec()</a> and <a href="#is_vec">.is_rowvec()</a></li>
 </ul>
 <br>

examples/example1.cpp

@@ -1,7 +1,9 @@
 #include <iostream>
 #include <armadillo>
 
-using namespace std;
+using std::cout;
+using std::endl;
+
 using namespace arma;
 
 // Armadillo documentation is available at:

include/armadillo_bits/Base_bones.hpp

@@ -130,8 +130,8 @@ struct Base
   arma_frown("use .index_min() instead") inline elem_type min(uword& index_of_min_val) const;
   arma_frown("use .index_max() instead") inline elem_type max(uword& index_of_max_val) const;
   
-  arma_deprecated inline elem_type min(uword& row_of_min_val, uword& col_of_min_val) const;
-  arma_deprecated inline elem_type max(uword& row_of_max_val, uword& col_of_max_val) const;
+  arma_frown("use .index_min() with ind2sub() instead") inline elem_type min(uword& row_of_min_val, uword& col_of_min_val) const;
+  arma_frown("use .index_max() with ind2sub() instead") inline elem_type max(uword& row_of_max_val, uword& col_of_max_val) const;
   
   arma_warn_unused inline uword index_min() const;
   arma_warn_unused inline uword index_max() const;

include/armadillo_bits/Col_bones.hpp

@@ -187,6 +187,8 @@ class Col<eT>::fixed : public Col<eT>
   {
   private:
   
+  using Mat<eT>::mem_local;
+  
   static constexpr bool use_extra = (fixed_n_elem > arma_config::mat_prealloc);
   
   arma_align_mem eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ];

include/armadillo_bits/Col_meat.hpp

@@ -1345,11 +1345,11 @@ Col<eT>::fixed<fixed_n_elem>::fixed(const fill::fill_class<fill_type>&)
   {
   arma_debug_sigprint_this(this);
   
-  if(is_same_type<fill_type, fill::fill_zeros>::yes)  { (*this).zeros(); }
-  if(is_same_type<fill_type, fill::fill_ones >::yes)  { (*this).ones();  }
-  if(is_same_type<fill_type, fill::fill_eye  >::yes)  { (*this).eye();   }
-  if(is_same_type<fill_type, fill::fill_randu>::yes)  { (*this).randu(); }
-  if(is_same_type<fill_type, fill::fill_randn>::yes)  { (*this).randn(); }
+  if(is_same_type<fill_type, fill::fill_zeros>::yes)  {  (*this).zeros(); }
+  if(is_same_type<fill_type, fill::fill_ones >::yes)  {  (*this).ones();  }
+  if(is_same_type<fill_type, fill::fill_eye  >::yes)  { Mat<eT>::eye();   }
+  if(is_same_type<fill_type, fill::fill_randu>::yes)  { Mat<eT>::randu(); }
+  if(is_same_type<fill_type, fill::fill_randn>::yes)  { Mat<eT>::randn(); }
   }
 
 

include/armadillo_bits/Cube_bones.hpp

@@ -390,8 +390,8 @@ class Cube : public BaseCube< eT, Cube<eT> >
   arma_frown("use .index_min() instead") inline eT min(uword& index_of_min_val) const;
   arma_frown("use .index_max() instead") inline eT max(uword& index_of_max_val) const;
   
-  arma_deprecated inline eT min(uword& row_of_min_val, uword& col_of_min_val, uword& slice_of_min_val) const;
-  arma_deprecated inline eT max(uword& row_of_max_val, uword& col_of_max_val, uword& slice_of_max_val) const;
+  arma_frown("use .index_min() with ind2sub() instead") inline eT min(uword& row_of_min_val, uword& col_of_min_val, uword& slice_of_min_val) const;
+  arma_frown("use .index_max() with ind2sub() instead") inline eT max(uword& row_of_max_val, uword& col_of_max_val, uword& slice_of_max_val) const;
   
   arma_cold inline bool save(const std::string   name, const file_type type = arma_binary) const;
   arma_cold inline bool save(const hdf5_name&    spec, const file_type type = hdf5_binary) const;
@@ -485,6 +485,9 @@ class Cube<eT>::fixed : public Cube<eT>
   {
   private:
   
+  using Cube<eT>::mat_ptrs_local;
+  using Cube<eT>::mem_local;
+  
   static constexpr uword fixed_n_elem       = fixed_n_rows * fixed_n_cols * fixed_n_slices;
   static constexpr uword fixed_n_elem_slice = fixed_n_rows * fixed_n_cols;
   

include/armadillo_bits/Cube_meat.hpp

@@ -3448,7 +3448,7 @@ Cube<eT>::at_alt(const uword i) const
 
 
 
-//! linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
+//! linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 eT&
@@ -3461,7 +3461,7 @@ Cube<eT>::operator() (const uword i)
 
 
 
-//! linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
+//! linear element accessor (treats the cube as a vector); bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 const eT&
@@ -3517,7 +3517,7 @@ Cube<eT>::at(const uword i) const
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 eT&
@@ -3537,7 +3537,7 @@ Cube<eT>::operator() (const uword in_row, const uword in_col, const uword in_sli
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 const eT&
@@ -5412,10 +5412,10 @@ Cube<eT>::fixed<fixed_n_rows, fixed_n_cols, fixed_n_slices>::fixed(const fill::f
   
   mem_setup();
   
-  if(is_same_type<fill_type, fill::fill_zeros>::yes)  { (*this).zeros(); }
-  if(is_same_type<fill_type, fill::fill_ones >::yes)  { (*this).ones();  }
-  if(is_same_type<fill_type, fill::fill_randu>::yes)  { (*this).randu(); }
-  if(is_same_type<fill_type, fill::fill_randn>::yes)  { (*this).randn(); }
+  if(is_same_type<fill_type, fill::fill_zeros>::yes)  { Cube<eT>::zeros(); }
+  if(is_same_type<fill_type, fill::fill_ones >::yes)  { Cube<eT>::ones();  }
+  if(is_same_type<fill_type, fill::fill_randu>::yes)  { Cube<eT>::randu(); }
+  if(is_same_type<fill_type, fill::fill_randn>::yes)  { Cube<eT>::randn(); }
   
   arma_static_check( (is_same_type<fill_type, fill::fill_eye>::yes), "Cube::fixed::fixed(): unsupported fill type" );
   }

include/armadillo_bits/Mat_bones.hpp

@@ -544,8 +544,8 @@ class Mat : public Base< eT, Mat<eT> >
   arma_frown("use .index_min() instead") inline eT min(uword& index_of_min_val) const;
   arma_frown("use .index_max() instead") inline eT max(uword& index_of_max_val) const;
   
-  arma_deprecated inline eT min(uword& row_of_min_val, uword& col_of_min_val) const;
-  arma_deprecated inline eT max(uword& row_of_max_val, uword& col_of_max_val) const;
+  arma_frown("use .index_min() with ind2sub() instead") inline eT min(uword& row_of_min_val, uword& col_of_min_val) const;
+  arma_frown("use .index_max() with ind2sub() instead") inline eT max(uword& row_of_max_val, uword& col_of_max_val) const;
   
   
   arma_cold inline bool save(const std::string   name, const file_type type = arma_binary) const;
@@ -825,6 +825,8 @@ class Mat<eT>::fixed : public Mat<eT>
   {
   private:
   
+  using Mat<eT>::mem_local;
+  
   static constexpr uword fixed_n_elem = fixed_n_rows * fixed_n_cols;
   static constexpr bool  use_extra    = (fixed_n_elem > arma_config::mat_prealloc);
   

include/armadillo_bits/Mat_meat.hpp

@@ -6391,7 +6391,7 @@ Mat<eT>::at_alt(const uword ii) const
 
 
 
-//! linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
+//! linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 eT&
@@ -6404,7 +6404,7 @@ Mat<eT>::operator() (const uword ii)
 
 
 
-//! linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
+//! linear element accessor (treats the matrix as a vector); bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 const eT&
@@ -6460,7 +6460,7 @@ Mat<eT>::at(const uword ii) const
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 eT&
@@ -6473,7 +6473,7 @@ Mat<eT>::operator() (const uword in_row, const uword in_col)
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename eT>
 arma_inline
 const eT&
@@ -9565,11 +9565,11 @@ Mat<eT>::fixed<fixed_n_rows, fixed_n_cols>::fixed(const fill::fill_class<fill_ty
   {
   arma_debug_sigprint_this(this);
   
-  if(is_same_type<fill_type, fill::fill_zeros>::yes)  { (*this).zeros(); }
-  if(is_same_type<fill_type, fill::fill_ones >::yes)  { (*this).ones();  }
-  if(is_same_type<fill_type, fill::fill_eye  >::yes)  { (*this).eye();   }
-  if(is_same_type<fill_type, fill::fill_randu>::yes)  { (*this).randu(); }
-  if(is_same_type<fill_type, fill::fill_randn>::yes)  { (*this).randn(); }
+  if(is_same_type<fill_type, fill::fill_zeros>::yes)  {  (*this).zeros(); }
+  if(is_same_type<fill_type, fill::fill_ones >::yes)  {  (*this).ones();  }
+  if(is_same_type<fill_type, fill::fill_eye  >::yes)  { Mat<eT>::eye();   }
+  if(is_same_type<fill_type, fill::fill_randu>::yes)  { Mat<eT>::randu(); }
+  if(is_same_type<fill_type, fill::fill_randn>::yes)  { Mat<eT>::randn(); }
   }
 
 

include/armadillo_bits/Row_bones.hpp

@@ -187,6 +187,8 @@ class Row<eT>::fixed : public Row<eT>
   {
   private:
   
+  using Mat<eT>::mem_local;
+  
   static constexpr bool use_extra = (fixed_n_elem > arma_config::mat_prealloc);
   
   arma_align_mem eT mem_local_extra[ (use_extra) ? fixed_n_elem : 1 ];

include/armadillo_bits/Row_meat.hpp

@@ -1345,11 +1345,11 @@ Row<eT>::fixed<fixed_n_elem>::fixed(const fill::fill_class<fill_type>&)
   {
   arma_debug_sigprint_this(this);
   
-  if(is_same_type<fill_type, fill::fill_zeros>::yes)  { (*this).zeros(); }
-  if(is_same_type<fill_type, fill::fill_ones >::yes)  { (*this).ones();  }
-  if(is_same_type<fill_type, fill::fill_eye  >::yes)  { (*this).eye();   }
-  if(is_same_type<fill_type, fill::fill_randu>::yes)  { (*this).randu(); }
-  if(is_same_type<fill_type, fill::fill_randn>::yes)  { (*this).randn(); }
+  if(is_same_type<fill_type, fill::fill_zeros>::yes)  {  (*this).zeros(); }
+  if(is_same_type<fill_type, fill::fill_ones >::yes)  {  (*this).ones();  }
+  if(is_same_type<fill_type, fill::fill_eye  >::yes)  { Mat<eT>::eye();   }
+  if(is_same_type<fill_type, fill::fill_randu>::yes)  { Mat<eT>::randu(); }
+  if(is_same_type<fill_type, fill::fill_randn>::yes)  { Mat<eT>::randn(); }
   }
 
 

include/armadillo_bits/SpBase_bones.hpp

@@ -79,8 +79,8 @@ struct SpBase
   arma_frown("use .index_min() instead") inline elem_type min(uword& index_of_min_val) const;
   arma_frown("use .index_max() instead") inline elem_type max(uword& index_of_max_val) const;
   
-  arma_deprecated inline elem_type min(uword& row_of_min_val, uword& col_of_min_val) const;
-  arma_deprecated inline elem_type max(uword& row_of_max_val, uword& col_of_max_val) const;
+  arma_frown("use .index_min() with ind2sub() instead") inline elem_type min(uword& row_of_min_val, uword& col_of_min_val) const;
+  arma_frown("use .index_max() with ind2sub() instead") inline elem_type max(uword& row_of_max_val, uword& col_of_max_val) const;
   
   arma_warn_unused inline uword index_min() const;
   arma_warn_unused inline uword index_max() const;

include/armadillo_bits/arma_version.hpp

@@ -23,7 +23,7 @@
 
 #define ARMA_VERSION_MAJOR 14
 #define ARMA_VERSION_MINOR 2
-#define ARMA_VERSION_PATCH 0
+#define ARMA_VERSION_PATCH 3
 #define ARMA_VERSION_NAME  "Smooth Caffeine"
 
 

include/armadillo_bits/compiler_setup.hpp

@@ -169,7 +169,7 @@
   // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=57580
   
   #if (ARMA_GCC_VERSION < 80100)
-    #pragma message("INFO: support for GCC versions older than 8.1 is deprecated"
+    #pragma message("INFO: support for GCC versions older than 8.1 is deprecated")
   #endif
   
   #define ARMA_GOOD_COMPILER
@@ -477,9 +477,8 @@
 #undef major
 
 
-// optionally allow disabling of compile-time deprecation messages (not recommended)
-// NOTE: option 'ARMA_IGNORE_DEPRECATED_MARKER' will be removed
-// NOTE: disabling deprecation messages is counter-productive
+// WARNING: option 'ARMA_IGNORE_DEPRECATED_MARKER' will be removed;
+// WARNING: disabling deprecation messages is counter-productive
 
 #if defined(ARMA_IGNORE_DEPRECATED_MARKER)
   #undef  arma_deprecated

include/armadillo_bits/config.hpp

@@ -366,6 +366,9 @@
   #undef ARMA_CRIPPLED_LAPACK
 #endif
 
+// WARNING: option ARMA_IGNORE_DEPRECATED_MARKER will be removed
+// WARNING: option ARMA_CRIPPLED_LAPACK          will be removed
+
 #if defined(ARMA_CRIPPLED_LAPACK)
   #if (!defined(ARMA_IGNORE_DEPRECATED_MARKER))
     #pragma message ("option ARMA_CRIPPLED_LAPACK is deprecated and will be removed")

include/armadillo_bits/config.hpp.cmake

@@ -366,6 +366,9 @@
   #undef ARMA_CRIPPLED_LAPACK
 #endif
 
+// WARNING: option ARMA_IGNORE_DEPRECATED_MARKER will be removed
+// WARNING: option ARMA_CRIPPLED_LAPACK          will be removed
+
 #if defined(ARMA_CRIPPLED_LAPACK)
   #if (!defined(ARMA_IGNORE_DEPRECATED_MARKER))
     #pragma message ("option ARMA_CRIPPLED_LAPACK is deprecated and will be removed")

include/armadillo_bits/def_lapack.hpp

@@ -919,12 +919,12 @@ extern "C"
   void arma_fortran(arma_zhetri)(const char* uplo, const blas_int* n, blas_cxd* a, const blas_int* lda, const blas_int* ipiv, blas_cxd* work, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
   
   // rcond of symmetric matrix using pre-computed factorisation (real)
-  void arma_fortran(arma_ssycon)(const char* uplo, const blas_int* n, float*    a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, float*    work, blas_int* iwork, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
-  void arma_fortran(arma_dsycon)(const char* uplo, const blas_int* n, double*   a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double*   work, blas_int* iwork, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
+  void arma_fortran(arma_ssycon)(const char* uplo, const blas_int* n, const float*    a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, float*    work, blas_int* iwork, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
+  void arma_fortran(arma_dsycon)(const char* uplo, const blas_int* n, const double*   a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double*   work, blas_int* iwork, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
   
   // rcond of hermitian matrix using pre-computed factorisation (complex)
-  void arma_fortran(arma_checon)(const char* uplo, const blas_int* n, blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
-  void arma_fortran(arma_zhecon)(const char* uplo, const blas_int* n, blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
+  void arma_fortran(arma_checon)(const char* uplo, const blas_int* n, const blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
+  void arma_fortran(arma_zhecon)(const char* uplo, const blas_int* n, const blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info, blas_len uplo_len) ARMA_NOEXCEPT;
   
 #else
   
@@ -1275,12 +1275,12 @@ extern "C"
   void arma_fortran(arma_zhetri)(const char* uplo, const blas_int* n, blas_cxd* a, const blas_int* lda, const blas_int* ipiv, blas_cxd* work, blas_int* info) ARMA_NOEXCEPT;
   
   // rcond of symmetric matrix using pre-computed factorisation (real)
-  void arma_fortran(arma_ssycon)(const char* uplo, const blas_int* n, float*    a, const blas_int* lda, const blas_int* ipiv, const float*  anorm,  float* rcond, float*    work, blas_int* iwork, blas_int* info) ARMA_NOEXCEPT;
-  void arma_fortran(arma_dsycon)(const char* uplo, const blas_int* n, double*   a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double*   work, blas_int* iwork, blas_int* info) ARMA_NOEXCEPT;
+  void arma_fortran(arma_ssycon)(const char* uplo, const blas_int* n, const float*    a, const blas_int* lda, const blas_int* ipiv, const float*  anorm,  float* rcond, float*    work, blas_int* iwork, blas_int* info) ARMA_NOEXCEPT;
+  void arma_fortran(arma_dsycon)(const char* uplo, const blas_int* n, const double*   a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double*   work, blas_int* iwork, blas_int* info) ARMA_NOEXCEPT;
   
   // rcond of hermitian matrix using pre-computed factorisation (complex)
-  void arma_fortran(arma_checon)(const char* uplo, const blas_int* n, blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info) ARMA_NOEXCEPT;
-  void arma_fortran(arma_zhecon)(const char* uplo, const blas_int* n, blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info) ARMA_NOEXCEPT;
+  void arma_fortran(arma_checon)(const char* uplo, const blas_int* n, const blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info) ARMA_NOEXCEPT;
+  void arma_fortran(arma_zhecon)(const char* uplo, const blas_int* n, const blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info) ARMA_NOEXCEPT;
   
 #endif
 }

include/armadillo_bits/fft_engine_fftw3.hpp

@@ -50,7 +50,8 @@ class fft_engine_fftw3
   podarray<cx_type> Y_work;  // for storing output
   
   inline
-  ~fft_engine_fftw3()
+  void
+  finish()
     {
     arma_debug_sigprint();
     
@@ -59,6 +60,33 @@ class fft_engine_fftw3
     // fftw3::cleanup<cx_type>();  // NOTE: this also removes any wisdom acquired by FFTW3 
     }
   
+  inline
+  ~fft_engine_fftw3()
+    {
+    arma_debug_sigprint();
+    
+    #if defined(ARMA_USE_OPENMP)
+      {
+      #pragma omp critical (arma_fft_engine_fftw3)
+        {
+        (*this).finish();
+        }
+      }
+    #elif defined(ARMA_USE_STD_MUTEX)
+      {
+      std::mutex& plan_mutex = fft_engine_fftw3_aux::get_plan_mutex();
+      
+      const std::lock_guard<std::mutex> lock(plan_mutex);
+      
+      (*this).finish();
+      }
+    #else
+      {
+      (*this).finish();
+      }
+    #endif
+    }
+  
   inline
   fft_engine_fftw3(const uword in_N)
     : N         (in_N   )

include/armadillo_bits/field_meat.hpp

@@ -531,7 +531,7 @@ field<oT>::at(const uword i) const
 
 
 
-//! linear element accessor (treats the field as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
+//! linear element accessor (treats the field as a vector); bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename oT>
 arma_inline
 oT&
@@ -544,7 +544,7 @@ field<oT>::operator() (const uword i)
 
 
 
-//! linear element accessor (treats the field as a vector); bounds checking not done when ARMA_NO_DEBUG is defined
+//! linear element accessor (treats the field as a vector); bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename oT>
 arma_inline
 const oT&
@@ -557,7 +557,7 @@ field<oT>::operator() (const uword i) const
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename oT>
 arma_inline
 oT&
@@ -570,7 +570,7 @@ field<oT>::operator() (const uword in_row, const uword in_col)
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename oT>
 arma_inline
 const oT&
@@ -583,7 +583,7 @@ field<oT>::operator() (const uword in_row, const uword in_col) const
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename oT>
 arma_inline
 oT&
@@ -596,7 +596,7 @@ field<oT>::operator() (const uword in_row, const uword in_col, const uword in_sl
 
 
 
-//! element accessor; bounds checking not done when ARMA_NO_DEBUG is defined
+//! element accessor; bounds checking not done when ARMA_DONT_CHECK_CONFORMANCE is defined
 template<typename oT>
 arma_inline
 const oT&

include/armadillo_bits/fn_accu.hpp

@@ -840,7 +840,7 @@ accu(const BaseCube<typename T1::elem_type,T1>& X)
   
   if(is_Cube<typename ProxyCube<T1>::stored_type>::value)
     {
-    unwrap_cube<typename ProxyCube<T1>::stored_type> tmp(P.Q);
+    const unwrap_cube<typename ProxyCube<T1>::stored_type> tmp(P.Q);
     
     return arrayops::accumulate(tmp.M.memptr(), tmp.M.n_elem);
     }
@@ -993,6 +993,8 @@ accu(const SpGlue<T1,T2,spglue_schur>& expr)
   const SpProxy<T1> px(expr.A);
   const SpProxy<T2> py(expr.B);
   
+  arma_conform_assert_same_size(px.get_n_rows(), px.get_n_cols(), py.get_n_rows(), py.get_n_cols(), "element-wise multiplication");
+  
   typename SpProxy<T1>::const_iterator_type x_it     = px.begin();
   typename SpProxy<T1>::const_iterator_type x_it_end = px.end();
   

include/armadillo_bits/gmm_full_meat.hpp

@@ -937,7 +937,7 @@ gmm_full<eT>::init_constants(const bool calc_chol)
           Mat<eT>& inv_fcov =  inv_fcovs.slice(g);
     
   //const bool inv_ok = auxlib::inv(tmp_inv, fcov);
-    const bool inv_ok = auxlib::inv_sympd(tmp_inv, fcov);
+    const bool inv_ok = auxlib::inv_sympd(tmp_inv, fcov);  // using inv_sympd() instead of inv() to ensure we can do cholesky decomp via op_chol
     
     eT log_det_val  = eT(0);
     eT log_det_sign = eT(0);

include/armadillo_bits/op_max_meat.hpp

@@ -393,32 +393,19 @@ op_max::direct_max(const eT* const X, const uword n_elem, uword& index_of_max_va
   {
   arma_debug_sigprint();
   
-  eT max_val_i = priv::most_neg<eT>();
-  eT max_val_j = priv::most_neg<eT>();
+  eT    best_val   = priv::most_neg<eT>();
+  uword best_index = 0;
   
-  uword best_index_i = 0;
-  uword best_index_j = 0;
-  
-  uword i,j;
-  for(i=0, j=1; j<n_elem; i+=2, j+=2)
+  for(uword i=0; i < n_elem; ++i)
     {
-    const eT X_i = X[i];
-    const eT X_j = X[j];
+    const eT val = X[i];
     
-    if(X_i > max_val_i)  { max_val_i = X_i; best_index_i = i; }
-    if(X_j > max_val_j)  { max_val_j = X_j; best_index_j = j; }
+    if(val > best_val)  { best_val = val; best_index = i; }
     }
   
-  if(i < n_elem)
-    {
-    const eT X_i = X[i];
-    
-    if(X_i > max_val_i)  { max_val_i = X_i; best_index_i = i; }
-    }
+  index_of_max_val = best_index;
   
-  index_of_max_val = (max_val_i > max_val_j) ? best_index_i : best_index_j;
-  
-  return (max_val_i > max_val_j) ? max_val_i : max_val_j;
+  return best_val;
   }
 
 
@@ -705,6 +692,8 @@ op_max::max_with_index(const Proxy<T1>& P, uword& index_of_max_val)
     {
     arma_conform_check(true, "max(): object has no elements");
     
+    index_of_max_val = 0;
+    
     return Datum<eT>::nan;
     }
   
@@ -786,6 +775,8 @@ op_max::max_with_index(const ProxyCube<T1>& P, uword& index_of_max_val)
     {
     arma_conform_check(true, "max(): object has no elements");
     
+    index_of_max_val = 0;
+    
     return Datum<eT>::nan;
     }
   
@@ -1160,6 +1151,8 @@ op_max::max_with_index(const Proxy<T1>& P, uword& index_of_max_val)
     {
     arma_conform_check(true, "max(): object has no elements");
     
+    index_of_max_val = 0;
+    
     return Datum<eT>::nan;
     }
   
@@ -1263,6 +1256,8 @@ op_max::max_with_index(const ProxyCube<T1>& P, uword& index_of_max_val)
     {
     arma_conform_check(true, "max(): object has no elements");
     
+    index_of_max_val = 0;
+    
     return Datum<eT>::nan;
     }
   

include/armadillo_bits/op_median_meat.hpp

@@ -41,7 +41,7 @@ op_median::apply(Mat<typename T1::elem_type>& out, const Op<T1,op_median>& expr)
     {
     Mat<eT> tmp;
     
-    op_median::apply_noalias(out, U.M, dim);
+    op_median::apply_noalias(tmp, U.M, dim);
     
     out.steal_mem(tmp);
     }

include/armadillo_bits/op_min_meat.hpp

@@ -393,32 +393,19 @@ op_min::direct_min(const eT* const X, const uword n_elem, uword& index_of_min_va
   {
   arma_debug_sigprint();
   
-  eT min_val_i = priv::most_pos<eT>();
-  eT min_val_j = priv::most_pos<eT>();
+  eT    best_val   = priv::most_pos<eT>();
+  uword best_index = 0;
   
-  uword best_index_i = 0;
-  uword best_index_j = 0;
-  
-  uword i,j;
-  for(i=0, j=1; j<n_elem; i+=2, j+=2)
+  for(uword i=0; i < n_elem; ++i)
     {
-    const eT X_i = X[i];
-    const eT X_j = X[j];
+    const eT val = X[i];
     
-    if(X_i < min_val_i)  { min_val_i = X_i; best_index_i = i; }
-    if(X_j < min_val_j)  { min_val_j = X_j; best_index_j = j; }
+    if(val < best_val)  { best_val = val; best_index = i; }
     }
   
-  if(i < n_elem)
-    {
-    const eT X_i = X[i];
-    
-    if(X_i < min_val_i)  { min_val_i = X_i; best_index_i = i; }
-    }
+  index_of_min_val = best_index;
   
-  index_of_min_val = (min_val_i < min_val_j) ? best_index_i : best_index_j;
-  
-  return (min_val_i < min_val_j) ? min_val_i : min_val_j;
+  return best_val;
   }
 
 
@@ -705,6 +692,8 @@ op_min::min_with_index(const Proxy<T1>& P, uword& index_of_min_val)
     {
     arma_conform_check(true, "min(): object has no elements");
     
+    index_of_min_val = 0;
+    
     return Datum<eT>::nan;
     }
   
@@ -786,6 +775,8 @@ op_min::min_with_index(const ProxyCube<T1>& P, uword& index_of_min_val)
     {
     arma_conform_check(true, "min(): object has no elements");
     
+    index_of_min_val = 0;
+    
     return Datum<eT>::nan;
     }
   
@@ -1160,6 +1151,8 @@ op_min::min_with_index(const Proxy<T1>& P, uword& index_of_min_val)
     {
     arma_conform_check(true, "min(): object has no elements");
     
+    index_of_min_val = 0;
+    
     return Datum<eT>::nan;
     }
   
@@ -1263,6 +1256,8 @@ op_min::min_with_index(const ProxyCube<T1>& P, uword& index_of_min_val)
     {
     arma_conform_check(true, "min(): object has no elements");
     
+    index_of_min_val = 0;
+    
     return Datum<eT>::nan;
     }
   

include/armadillo_bits/op_reshape_meat.hpp

@@ -81,12 +81,19 @@ op_reshape::apply_mat_inplace(Mat<eT>& A, const uword new_n_rows, const uword ne
   {
   arma_debug_sigprint();
   
+  if( (A.n_rows == new_n_rows) && (A.n_cols == new_n_cols) )  { return; }
+  
   arma_conform_check( (A.vec_state == 1) && (new_n_cols != 1), "reshape(): requested size is not compatible with column vector layout" );
   arma_conform_check( (A.vec_state == 2) && (new_n_rows != 1), "reshape(): requested size is not compatible with row vector layout"    );
   
-  const uword new_n_elem = new_n_rows * new_n_cols;
+  if(A.is_empty())  { A.zeros(new_n_rows, new_n_cols); return; }
   
-  if(A.n_elem == new_n_elem)  { A.set_size(new_n_rows, new_n_cols); return; }
+  const bool is_into_empty  = ( (new_n_cols == uword(0)) || (new_n_rows == uword(0)) );
+  const bool is_into_colvec = ( (new_n_cols == uword(1)) && (new_n_rows == A.n_elem) );
+  const bool is_into_rowvec = ( (new_n_rows == uword(1)) && (new_n_cols == A.n_elem) );
+  const bool is_rowcol_swap = ( (new_n_cols == A.n_rows) && (new_n_rows == A.n_cols) );
+  
+  if(is_into_empty || is_into_colvec || is_into_rowvec || is_rowcol_swap)  { A.set_size(new_n_rows, new_n_cols); return; }
   
   Mat<eT> B;
   
@@ -208,9 +215,16 @@ op_reshape::apply_cube_inplace(Cube<eT>& A, const uword new_n_rows, const uword
   {
   arma_debug_sigprint();
   
-  const uword new_n_elem = new_n_rows * new_n_cols * new_n_slices;
+  if( (A.n_rows == new_n_rows) && (A.n_cols == new_n_cols) && (A.n_slices == new_n_slices) )  { return; }
   
-  if(A.n_elem == new_n_elem)  { A.set_size(new_n_rows, new_n_cols, new_n_slices); return; }
+  if(A.is_empty())  { A.zeros(new_n_rows, new_n_cols, new_n_slices); return; }
+  
+  const bool is_into_empty  = ( (new_n_cols == uword(0)) || (new_n_rows == uword(0)) || (new_n_slices == uword(0)  ) );
+  const bool is_into_colvec = ( (new_n_cols == uword(1)) && (new_n_rows == A.n_elem) && (new_n_slices == uword(1)  ) );
+  const bool is_into_rowvec = ( (new_n_rows == uword(1)) && (new_n_cols == A.n_elem) && (new_n_slices == uword(1)  ) );
+  const bool is_rowcol_swap = ( (new_n_cols == A.n_rows) && (new_n_rows == A.n_cols) && (new_n_slices == A.n_slices) );
+  
+  if(is_into_empty || is_into_colvec || is_into_rowvec || is_rowcol_swap)  { A.set_size(new_n_rows, new_n_cols, new_n_slices); return; }
   
   Cube<eT> B;
   

include/armadillo_bits/sp_auxlib_meat.hpp

@@ -2027,6 +2027,7 @@ sp_auxlib::run_aupd_plain
     arma_ignore(n_eigvals);
     arma_ignore(which);
     arma_ignore(X);
+    arma_ignore(Xst);
     arma_ignore(sym);
     arma_ignore(n);
     arma_ignore(tol);

include/armadillo_bits/sym_helper.hpp

@@ -50,19 +50,26 @@ guess_sympd_worker(const Mat<eT>& A)
   const eT* A_mem = A.memptr();
   const eT* A_col = A_mem;
   
+  bool diag_below_tol = true;
+  
   eT max_diag = eT(0);
   
   for(uword j=0; j < N; ++j)
     {
     const eT A_jj = A_col[j];
     
-    if(A_jj <= eT(0))  { return false; }
+    if(              A_jj  <= eT(0))  { return false; }
+    if(arma_isfinite(A_jj) == false)  { return false; }
+    
+    if(A_jj >= tol)  { diag_below_tol = false; }
     
     max_diag = (A_jj > max_diag) ? A_jj : max_diag;
     
     A_col += N;
     }
   
+  if(diag_below_tol)  { return false; }  // assume matrix is suspect if all diagonal elements are close to zero
+  
   A_col = A_mem;
   
   const uword Nm1 = N-1;
@@ -128,6 +135,8 @@ guess_sympd_worker(const Mat<eT>& A)
   const eT* A_mem = A.memptr();
   const eT* A_col = A_mem;
   
+  bool diag_below_tol = true;
+  
   T max_diag = T(0);
   
   for(uword j=0; j < N; ++j)
@@ -138,15 +147,21 @@ guess_sympd_worker(const Mat<eT>& A)
     const  T  A_jj_rabs =  std::abs(A_jj_r);
     const  T  A_jj_iabs =  std::abs(A_jj_i);
     
-    if(A_jj_r    <= T(0)     )  { return false; }  // real should be positive
-    if(A_jj_iabs >  tol      )  { return false; }  // imag should be approx zero
-    if(A_jj_iabs >  A_jj_rabs)  { return false; }  // corner case: real and imag are close to zero, and imag is dominant
+    if(              A_jj_r  <= T(0) )  { return false; }  // real should be positive
+    if(arma_isfinite(A_jj_r) == false)  { return false; }
+    
+    if(A_jj_iabs > tol      )  { return false; }  // imag should be approx zero
+    if(A_jj_iabs > A_jj_rabs)  { return false; }  // corner case: real and imag are close to zero, and imag is dominant
+    
+    if(A_jj_r >= tol)  { diag_below_tol = false; }
     
     max_diag = (A_jj_r > max_diag) ? A_jj_r : max_diag;
     
     A_col += N;
     }
   
+  if(diag_below_tol)  { return false; }  // assume matrix is suspect if all diagonal elements are close to zero
+  
   const T square_max_diag = max_diag * max_diag;
   
   if(arma_isfinite(square_max_diag) == false)  { return false; }
@@ -264,15 +279,21 @@ is_approx_sym_worker(const Mat<eT>& A)
   const eT* A_mem = A.memptr();
   const eT* A_col = A_mem;
   
+  bool diag_below_tol = true;
+  
   for(uword j=0; j < N; ++j)
     {
-    const eT& A_jj = A_col[j];
+    const eT A_jj = A_col[j];
     
     if(arma_isfinite(A_jj) == false)  { return false; }
     
+    if(std::abs(A_jj) >= tol)  { diag_below_tol = false; }
+    
     A_col += N;
     }
   
+  if(diag_below_tol)  { return false; }  // assume matrix is suspect if all diagonal elements are close to zero
+  
   A_col = A_mem;
   
   const uword Nm1 = N-1;
@@ -324,6 +345,8 @@ is_approx_sym_worker(const Mat<eT>& A)
   const eT* A_mem = A.memptr();
   const eT* A_col = A_mem;
   
+  bool diag_below_tol = true;
+  
   // ensure diagonal has approx real-only elements
   for(uword j=0; j < N; ++j)
     {
@@ -338,9 +361,13 @@ is_approx_sym_worker(const Mat<eT>& A)
     
     if(arma_isfinite(A_jj_r) == false)  { return false; }
     
+    if(A_jj_rabs >= tol)  { diag_below_tol = false; }
+    
     A_col += N;
     }
   
+  if(diag_below_tol)  { return false; }  // assume matrix is suspect if all diagonal elements are close to zero
+  
   A_col = A_mem;
   
   const uword Nm1 = N-1;

include/armadillo_bits/translate_lapack.hpp

@@ -1459,11 +1459,11 @@ namespace lapack
     arma_type_check(( is_supported_blas_type<eT>::value == false ));
     
     #if defined(ARMA_USE_FORTRAN_HIDDEN_ARGS)
-           if( is_float<eT>::value)  { typedef float  T; arma_fortran(arma_ssycon)(uplo, n, (T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info, 1); }
-      else if(is_double<eT>::value)  { typedef double T; arma_fortran(arma_dsycon)(uplo, n, (T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info, 1); }
+           if( is_float<eT>::value)  { typedef float  T; arma_fortran(arma_ssycon)(uplo, n, (const T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info, 1); }
+      else if(is_double<eT>::value)  { typedef double T; arma_fortran(arma_dsycon)(uplo, n, (const T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info, 1); }
     #else
-           if( is_float<eT>::value)  { typedef float  T; arma_fortran(arma_ssycon)(uplo, n, (T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info); }
-      else if(is_double<eT>::value)  { typedef double T; arma_fortran(arma_dsycon)(uplo, n, (T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info); }
+           if( is_float<eT>::value)  { typedef float  T; arma_fortran(arma_ssycon)(uplo, n, (const T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info); }
+      else if(is_double<eT>::value)  { typedef double T; arma_fortran(arma_dsycon)(uplo, n, (const T*)a, lda, ipiv, (const T*)anorm, (T*)rcond, (T*)work, iwork, info); }
     #endif
     }
   
@@ -1477,11 +1477,11 @@ namespace lapack
     arma_type_check(( is_supported_blas_type<T>::value == false ));
     
     #if defined(ARMA_USE_FORTRAN_HIDDEN_ARGS)
-           if( is_float<T>::value)  { typedef float  pod_T; typedef blas_cxf cx_T; arma_fortran(arma_checon)(uplo, n, (cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info, 1); }
-      else if(is_double<T>::value)  { typedef double pod_T; typedef blas_cxd cx_T; arma_fortran(arma_zhecon)(uplo, n, (cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info, 1); }
+           if( is_float<T>::value)  { typedef float  pod_T; typedef blas_cxf cx_T; arma_fortran(arma_checon)(uplo, n, (const cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info, 1); }
+      else if(is_double<T>::value)  { typedef double pod_T; typedef blas_cxd cx_T; arma_fortran(arma_zhecon)(uplo, n, (const cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info, 1); }
     #else
-           if( is_float<T>::value)  { typedef float  pod_T; typedef blas_cxf cx_T; arma_fortran(arma_checon)(uplo, n, (cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info); }
-      else if(is_double<T>::value)  { typedef double pod_T; typedef blas_cxd cx_T; arma_fortran(arma_zhecon)(uplo, n, (cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info); }
+           if( is_float<T>::value)  { typedef float  pod_T; typedef blas_cxf cx_T; arma_fortran(arma_checon)(uplo, n, (const cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info); }
+      else if(is_double<T>::value)  { typedef double pod_T; typedef blas_cxd cx_T; arma_fortran(arma_zhecon)(uplo, n, (const cx_T*)a, lda, ipiv, (const pod_T*)anorm, (pod_T*)rcond, (cx_T*)work, info); }
     #endif
     }
   

src/wrapper1.cpp

@@ -1361,24 +1361,24 @@ extern "C"
     
     
     
-    void arma_fortran_with_prefix(arma_ssycon)(const char* uplo, const blas_int* n, float*  a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, float*  work, blas_int* iwork, blas_int* info)
+    void arma_fortran_with_prefix(arma_ssycon)(const char* uplo, const blas_int* n, const float*  a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, float*  work, blas_int* iwork, blas_int* info)
       {
       arma_fortran_sans_prefix(arma_ssycon)(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info);
       }
     
-    void arma_fortran_with_prefix(arma_dsycon)(const char* uplo, const blas_int* n, double* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double* work, blas_int* iwork, blas_int* info)
+    void arma_fortran_with_prefix(arma_dsycon)(const char* uplo, const blas_int* n, const double* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double* work, blas_int* iwork, blas_int* info)
       {
       arma_fortran_sans_prefix(arma_dsycon)(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info);
       }
     
     
     
-    void arma_fortran_with_prefix(arma_checon)(const char* uplo, const blas_int* n, blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info)
+    void arma_fortran_with_prefix(arma_checon)(const char* uplo, const blas_int* n, const blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info)
       {
       arma_fortran_sans_prefix(arma_checon)(uplo, n, a, lda, ipiv, anorm, rcond, work, info);
       }
     
-    void arma_fortran_with_prefix(arma_zhecon)(const char* uplo, const blas_int* n, blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info)
+    void arma_fortran_with_prefix(arma_zhecon)(const char* uplo, const blas_int* n, const blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info)
       {
       arma_fortran_sans_prefix(arma_zhecon)(uplo, n, a, lda, ipiv, anorm, rcond, work, info);
       }

src/wrapper2.cpp

@@ -1230,24 +1230,24 @@ extern "C"
     
     
     
-    void arma_fortran_with_prefix(arma_ssycon)(const char* uplo, const blas_int* n, float*  a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, float*  work, blas_int* iwork, blas_int* info, blas_len uplo_len)
+    void arma_fortran_with_prefix(arma_ssycon)(const char* uplo, const blas_int* n, const float*  a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, float*  work, blas_int* iwork, blas_int* info, blas_len uplo_len)
       {
       arma_fortran_sans_prefix(arma_ssycon)(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info, uplo_len);
       }
     
-    void arma_fortran_with_prefix(arma_dsycon)(const char* uplo, const blas_int* n, double* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double* work, blas_int* iwork, blas_int* info, blas_len uplo_len)
+    void arma_fortran_with_prefix(arma_dsycon)(const char* uplo, const blas_int* n, const double* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, double* work, blas_int* iwork, blas_int* info, blas_len uplo_len)
       {
       arma_fortran_sans_prefix(arma_dsycon)(uplo, n, a, lda, ipiv, anorm, rcond, work, iwork, info, uplo_len);
       }
     
     
     
-    void arma_fortran_with_prefix(arma_checon)(const char* uplo, const blas_int* n, blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info, blas_len uplo_len)
+    void arma_fortran_with_prefix(arma_checon)(const char* uplo, const blas_int* n, const blas_cxf* a, const blas_int* lda, const blas_int* ipiv, const float*  anorm, float*  rcond, blas_cxf* work, blas_int* info, blas_len uplo_len)
       {
       arma_fortran_sans_prefix(arma_checon)(uplo, n, a, lda, ipiv, anorm, rcond, work, info, uplo_len);
       }
     
-    void arma_fortran_with_prefix(arma_zhecon)(const char* uplo, const blas_int* n, blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info, blas_len uplo_len)
+    void arma_fortran_with_prefix(arma_zhecon)(const char* uplo, const blas_int* n, const blas_cxd* a, const blas_int* lda, const blas_int* ipiv, const double* anorm, double* rcond, blas_cxd* work, blas_int* info, blas_len uplo_len)
       {
       arma_fortran_sans_prefix(arma_zhecon)(uplo, n, a, lda, ipiv, anorm, rcond, work, info, uplo_len);
       }