Hello community, here is the log from the commit of package armadillo for openSUSE:Factory checked in at 2015-10-24 18:56:25 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/armadillo (Old) and /work/SRC/openSUSE:Factory/.armadillo.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "armadillo" Changes: -------- --- /work/SRC/openSUSE:Factory/armadillo/armadillo.changes 2015-10-20 00:06:07.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.armadillo.new/armadillo.changes 2015-10-24 18:56:40.000000000 +0200 @@ -1,0 +2,6 @@ +Sat Oct 24 02:44:52 UTC 2015 - [email protected] + +- Update to version 6.100.1: + + Bug fixes (undocumented by upstream). + +------------------------------------------------------------------- Old: ---- armadillo-6.100.0.tar.gz New: ---- armadillo-6.100.1.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ armadillo.spec ++++++ --- /var/tmp/diff_new_pack.L7nnAK/_old 2015-10-24 18:56:41.000000000 +0200 +++ /var/tmp/diff_new_pack.L7nnAK/_new 2015-10-24 18:56:41.000000000 +0200 @@ -19,7 +19,7 @@ %define soname libarmadillo6 Name: armadillo -Version: 6.100.0 +Version: 6.100.1 Release: 0 Summary: Fast C++ matrix library with interfaces to LAPACK and ATLAS License: MPL-2.0 ++++++ armadillo-6.100.0.tar.gz -> armadillo-6.100.1.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/CMakeLists.txt new/armadillo-6.100.1/CMakeLists.txt --- old/armadillo-6.100.0/CMakeLists.txt 2015-10-02 04:44:31.000000000 +0200 +++ new/armadillo-6.100.1/CMakeLists.txt 2015-10-20 17:37:12.000000000 +0200 @@ -14,7 +14,7 @@ set(ARMA_MAJOR 6) set(ARMA_MINOR 100) -set(ARMA_PATCH 0) +set(ARMA_PATCH 1) set(ARMADILLO_VERSION ${ARMA_MAJOR}.${ARMA_MINOR}.${ARMA_PATCH}) message(STATUS "Configuring Armadillo ${ARMADILLO_VERSION}") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/README.txt new/armadillo-6.100.1/README.txt --- old/armadillo-6.100.0/README.txt 2015-10-02 04:44:31.000000000 +0200 +++ new/armadillo-6.100.1/README.txt 2015-10-20 17:37:12.000000000 +0200 @@ -192,7 +192,7 @@ If you want to use Armadillo without installation, or you're getting linking errors, compile along these lines: - g++ example1.cpp -o example1 -O2 -I /home/blah/armadillo-6.100.0-test/include -DARMA_DONT_USE_WRAPPER -lblas -llapack + g++ example1.cpp -o example1 -O2 -I /home/blah/armadillo-6.100.1/include -DARMA_DONT_USE_WRAPPER -lblas -llapack The above command line assumes that you have unpacked the armadillo archive into /home/blah/ You will need to adjust this for later versions of Armadillo, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/docs.html new/armadillo-6.100.1/docs.html --- old/armadillo-6.100.0/docs.html 2015-10-02 05:06:58.000000000 +0200 +++ new/armadillo-6.100.1/docs.html 2015-10-22 20:11:16.000000000 +0200 @@ -634,38 +634,38 @@ <br> <br> <ul> -<code>mat(*aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false)</code> +<code>mat(ptr_aux_mem, n_rows, n_cols, copy_aux_mem = true, strict = false)</code> <br> <br> <ul> -Create a matrix using data from writable auxiliary (external) memory. +Create a matrix using data from writable auxiliary (external) memory, where <i>ptr_aux_mem</i> is a pointer to the memory. By default the matrix allocates its own memory and copies data from the auxiliary memory (for safety). However, if <i>copy_aux_mem</i> is set to <i>false</i>, -the matrix will instead directly use the auxiliary memory (ie. no copying). -This is faster, but can be dangerous unless you know what you're doing! +the matrix will instead directly use the auxiliary memory (ie. no copying); +this is faster, but can be dangerous unless you know what you're doing! <br> <br> The <i>strict</i> parameter comes into effect only when <i>copy_aux_mem</i> is set to <i>false</i> -(ie. the matrix is directly using auxiliary memory). +(ie. the matrix is directly using auxiliary memory) <ul> <li> -When <i>strict</i> is set to <i>false</i>, the matrix will use the auxiliary memory and allow size changes; -if a size change results in the number of elements to increase, new memory will be allocated and the auxiliary memory will no longer be used +when <i>strict</i> is set to <i>false</i>, the matrix will use the auxiliary memory until a size change </li> <li> -When <i>strict</i> is set to <i>true</i>, the matrix will be bound to the auxiliary memory for its lifetime; -the number of elements in the matrix can't be changed (directly or indirectly) +when <i>strict</i> is set to <i>true</i>, the matrix will be bound to the auxiliary memory for its lifetime; +the number of elements in the matrix can't be changed </li> -<li>The default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> -<li>The default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> +<li>the default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> +<li>the default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> </ul> </ul> <br> -<code>mat(const *aux_mem, n_rows, n_cols)</code> +<code>mat(const ptr_aux_mem, n_rows, n_cols)</code> <br> <br> <ul> -Create a matrix by copying data from read-only auxiliary memory. +Create a matrix by copying data from read-only auxiliary memory, +where <i>ptr_aux_mem</i> is a pointer to the memory </ul> <a name="adv_constructors_mat_fixed"></a> <br> @@ -686,12 +686,12 @@ while <i>cx_mat44</i> is equivalent to <i>cx_mat::fixed<4,4></i>. </ul> <br> -<code>mat::fixed<n_rows, n_cols>(const *aux_mem)</code> +<code>mat::fixed<n_rows, n_cols>(const ptr_aux_mem)</code> <br> <br> <ul> -Create a fixed size matrix, with the size specified via template arguments, -and copying data from auxiliary memory. +Create a fixed size matrix, with the size specified via template arguments; +data is copied from auxiliary memory, where <i>ptr_aux_mem</i> is a pointer to the memory </ul> </ul> </li> @@ -930,38 +930,38 @@ <br> <br> <ul> -<code>vec(*aux_mem, number_of_elements, copy_aux_mem = true, strict = false)</code> +<code>vec(ptr_aux_mem, number_of_elements, copy_aux_mem = true, strict = false)</code> <br> <br> <ul> -Create a column vector using data from writable auxiliary (external) memory. +Create a column vector using data from writable auxiliary (external) memory, where <i>ptr_aux_mem</i> is a pointer to the memory. By default the vector allocates its own memory and copies data from the auxiliary memory (for safety). However, if <i>copy_aux_mem</i> is set to <i>false</i>, -the vector will instead directly use the auxiliary memory (ie. no copying). -This is faster, but can be dangerous unless you know what you're doing! +the vector will instead directly use the auxiliary memory (ie. no copying); +this is faster, but can be dangerous unless you know what you're doing! <br> <br> The <i>strict</i> parameter comes into effect only when <i>copy_aux_mem</i> is set to <i>false</i> -(ie. the vector is directly using auxiliary memory). +(ie. the vector is directly using auxiliary memory) <ul> <li> -When <i>strict</i> is set to <i>false</i>, the vector will use the auxiliary memory and allow size changes; -if a size change results in the number of elements to increase, new memory will be allocated and the auxiliary memory will no longer be used +when <i>strict</i> is set to <i>false</i>, the vector will use the auxiliary memory until a size change </li> <li> -When <i>strict</i> is set to <i>true</i>, the vector will be bound to the auxiliary memory for its lifetime; -the number of elements in the vector can't be changed (directly or indirectly) +when <i>strict</i> is set to <i>true</i>, the vector will be bound to the auxiliary memory for its lifetime; +the number of elements in the vector can't be changed </li> -<li>The default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> -<li>The default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> +<li>the default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> +<li>the default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> </ul> </ul> <br> -<code>vec(const *aux_mem, number_of_elements)</code> +<code>vec(const ptr_aux_mem, number_of_elements)</code> <br> <br> <ul> -Create a column vector by copying data from read-only auxiliary memory. +Create a column vector by copying data from read-only auxiliary memory, +where <i>ptr_aux_mem</i> is a pointer to the memory </ul> <a name="adv_constructors_col_fixed"></a> <br> @@ -982,12 +982,12 @@ while <i>cx_vec4</i> is equivalent to <i>cx_vec::fixed<4></i>. </ul> <br> -<code>vec::fixed<number_of_elements>(const *aux_mem)</code> +<code>vec::fixed<number_of_elements>(const ptr_aux_mem)</code> <br> <br> <ul> -Create a fixed size column vector, with the size specified via the template argument, -and copying data from auxiliary memory. +Create a fixed size column vector, with the size specified via the template argument; +data is copied from auxiliary memory, where <i>ptr_aux_mem</i> is a pointer to the memory </ul> </ul> </li> @@ -1161,38 +1161,38 @@ <br> <br> <ul> -<code>rowvec(*aux_mem, number_of_elements, copy_aux_mem = true, strict = false)</code> +<code>rowvec(ptr_aux_mem, number_of_elements, copy_aux_mem = true, strict = false)</code> <br> <br> <ul> -Create a row vector using data from writable auxiliary (external) memory. +Create a row vector using data from writable auxiliary (external) memory, where <i>ptr_aux_mem</i> is a pointer to the memory. By default the vector allocates its own memory and copies data from the auxiliary memory (for safety). However, if <i>copy_aux_mem</i> is set to <i>false</i>, -the vector will instead directly use the auxiliary memory (ie. no copying). -This is faster, but can be dangerous unless you know what you're doing! +the vector will instead directly use the auxiliary memory (ie. no copying); +this is faster, but can be dangerous unless you know what you're doing! <br> <br> The <i>strict</i> parameter comes into effect only when <i>copy_aux_mem</i> is set to <i>false</i> -(ie. the vector is directly using auxiliary memory). +(ie. the vector is directly using auxiliary memory) <ul> <li> -When <i>strict</i> is set to <i>false</i>, the vector will use the auxiliary memory and allow size changes; -if a size change results in the number of elements to increase, new memory will be allocated and the auxiliary memory will no longer be used +when <i>strict</i> is set to <i>false</i>, the vector will use the auxiliary memory until a size change </li> <li> -When <i>strict</i> is set to <i>true</i>, the vector will be bound to the auxiliary memory for its lifetime; -the number of elements in the vector can't be changed (directly or indirectly) +when <i>strict</i> is set to <i>true</i>, the vector will be bound to the auxiliary memory for its lifetime; +the number of elements in the vector can't be changed </li> -<li>The default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> -<li>The default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> +<li>the default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> +<li>the default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> </ul> </ul> <br> -<code>rowvec(const *aux_mem, number_of_elements)</code> +<code>rowvec(const ptr_aux_mem, number_of_elements)</code> <br> <br> <ul> -Create a row vector by copying data from read-only auxiliary memory. +Create a row vector by copying data from read-only auxiliary memory, +where <i>ptr_aux_mem</i> is a pointer to the memory </ul> <br> <code>rowvec::fixed<number_of_elements></code> @@ -1212,12 +1212,12 @@ while <i>cx_rowvec4</i> is equivalent to <i>cx_rowvec::fixed<4></i>. </ul> <br> -<code>rowvec::fixed<number_of_elements>(const *aux_mem)</code> +<code>rowvec::fixed<number_of_elements>(const ptr_aux_mem)</code> <br> <br> <ul> -Create a fixed size row vector, with the size specified via the template argument, -and copying data from auxiliary memory. +Create a fixed size row vector, with the size specified via the template argument; +data is copied from auxiliary memory, where <i>ptr_aux_mem</i> is a pointer to the memory </ul> </ul> </li> @@ -1407,38 +1407,38 @@ This is generally faster than dynamic memory allocation, but the size of the cube can't be changed afterwards (directly or indirectly). </ul> <br> -<code>cube(*aux_mem, n_rows, n_cols, n_slices, copy_aux_mem = true, strict = false)</code> +<code>cube(ptr_aux_mem, n_rows, n_cols, n_slices, copy_aux_mem = true, strict = false)</code> <br> <br> <ul> -Create a cube using data from writable auxiliary (external) memory. +Create a cube using data from writable auxiliary (external) memory, where <i>ptr_aux_mem</i> is a pointer to the memory. By default the cube allocates its own memory and copies data from the auxiliary memory (for safety). However, if <i>copy_aux_mem</i> is set to <i>false</i>, -the cube will instead directly use the auxiliary memory (ie. no copying). -This is faster, but can be dangerous unless you know what you're doing! +the cube will instead directly use the auxiliary memory (ie. no copying); +this is faster, but can be dangerous unless you know what you're doing! <br> <br> The <i>strict</i> parameter comes into effect only when <i>copy_aux_mem</i> is set to <i>false</i> -(ie. the cube is directly using auxiliary memory). +(ie. the cube is directly using auxiliary memory) <ul> <li> -When <i>strict</i> is set to <i>false</i>, the cube will use the auxiliary memory and allow size changes; -if a size change results in the number of elements to increase, new memory will be allocated and the auxiliary memory will no longer be used +when <i>strict</i> is set to <i>false</i>, the cube will use the auxiliary memory until a size change </li> <li> -When <i>strict</i> is set to <i>true</i>, the cube will be bound to the auxiliary memory for its lifetime; -the number of elements in the cube can't be changed (directly or indirectly) +when <i>strict</i> is set to <i>true</i>, the cube will be bound to the auxiliary memory for its lifetime; +the number of elements in the cube can't be changed </li> -<li>The default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> -<li>The default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> +<li>the default setting of <i>strict</i> in versions 6.000+ is <i>false</i></li> +<li>the default setting of <i>strict</i> in versions 5.600 and earlier is <i>true</i></li> </ul> </ul> <br> -<code>cube(const *aux_mem, n_rows, n_cols, n_slices)</code> +<code>cube(const ptr_aux_mem, n_rows, n_cols, n_slices)</code> <br> <br> <ul> -Create a cube by copying data from read-only auxiliary memory. +Create a cube by copying data from read-only auxiliary memory, +where <i>ptr_aux_mem</i> is a pointer to the memory </ul> </ul> </li> @@ -1768,7 +1768,7 @@ <li>fundamental arithmetic <a href="#operators">operations</a> (such as addition and multiplication)</li> <li><a href="#submat">submatrix views</a> (contiguous forms only)</li> <li><a href="#diag">diagonal views</a></li> -<li><a href="save_load_mat">saving and loading</a> (<i>arma_binary</i> format only)</li> +<li><a href="#save_load_mat">saving and loading</a> (using <i>arma_binary</i> format only)</li> <li>element-wise functions: <a href="#abs">abs()</a>, <a href="#imag_real">imag()</a>, <a href="#imag_real">real()</a>, <a href="#conj">conj()</a>, <a href="#misc_fns">sqrt()</a>, <a href="#misc_fns">square()</a></li> <li>scalar functions of matrices: <a href="#accu">accu()</a>, <a href="#as_scalar">as_scalar()</a>, <a href="#dot">dot()</a>, <a href="#norm">norm()</a>, <a href="#trace">trace()</a></li> <li>vector valued functions of matrices: <a href="#min_and_max">min()</a>, <a href="#min_and_max">max()</a>, <a href="#nonzeros">nonzeros()</a>, <a href="#sum">sum()</a>, <a href="#stats_fns">mean()</a>, <a href="#stats_fns">var()</a></li> @@ -3280,10 +3280,9 @@ The function <i>.unsafe_col()</i> is provided for speed reasons and should be used only if you know what you're doing. It creates a seemingly independent <i>Col</i> vector object (eg. <i>vec</i>), but uses memory from the existing matrix object. -As such, the created <i>Col</i> vector is not alias safe -and does not take into account that the parent matrix object could be deleted. -If deleted memory is accessed through the created <i>Col</i> vector, -it will cause memory corruption and/or a crash. +As such, the created vector is not alias safe, +and does not take into account that the underlying matrix memory could be freed +(eg. due to any operation involving a size change of the matrix). </li> <br> <li> @@ -9697,20 +9696,18 @@ <li>If <i>X</i> is not square, a <i>std::logic_error</i> exception is thrown</li> <br> <li> -The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code>, -with <code>"dc"</code> indicating divide-and-conquer and <code>"std"</code> indicating standard +The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code> <ul> <li> -In version 4.000 and later, the default method is <code>"dc"</code> +<code>"dc"</code> indicates divide-and-conquer method (default setting) </li> <li> -In version 3.930, the default method is <code>"std"</code> +<code>"std"</code> indicates standard method </li> -</ul> -</li> -<br> <li> -The divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +the divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +</li> +</ul> </li> <br> <li>If the decomposition fails: @@ -10475,20 +10472,18 @@ <li>Any singular values less than <i>tolerance</i> are treated as zero</li> <br> <li> -The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code>, -with <code>"dc"</code> indicating divide-and-conquer and <code>"std"</code> indicating standard +The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code> <ul> <li> -In version 4.000 and later, the default method is <code>"dc"</code> +<code>"dc"</code> indicates divide-and-conquer method (default setting) </li> <li> -In version 3.930, the default method is <code>"std"</code> -</li> -</ul> +<code>"std"</code> indicates standard method </li> -<br> <li> -The divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +the divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +</li> +</ul> </li> <br> <li>If the decomposition fails: @@ -11009,20 +11004,18 @@ </li> <br> <li> -The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code>, -with <code>"dc"</code> indicating divide-and-conquer and "std" indicating standard +The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code> <ul> <li> -In version 4.000 and later, the default method is <code>"dc"</code> +<code>"dc"</code> indicates divide-and-conquer method (default setting) </li> <li> -In version 3.930, the default method is <code>"std"</code> +<code>"std"</code> indicates standard method </li> -</ul> -</li> -<br> <li> -The divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +the divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +</li> +</ul> </li> <br> <li> @@ -11095,20 +11088,18 @@ </li> <br> <li> -The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code>, -with <code>"dc"</code> indicating divide-and-conquer and <code>"std"</code> indicating standard +The <i>method</i> argument is optional; <i>method</i> is either <code>"dc"</code> or <code>"std"</code> <ul> <li> -In version 4.000 and later, the default method is <code>"dc"</code> +<code>"dc"</code> indicates divide-and-conquer method (default setting) </li> <li> -In version 3.930, the default method is <code>"std"</code> -</li> -</ul> +<code>"std"</code> indicates standard method </li> -<br> <li> -The divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +the divide-and-conquer method provides slightly different results than the standard method, but is considerably faster for large matrices +</li> +</ul> </li> <br> <li> @@ -12858,8 +12849,11 @@ <br> <ul> <li> -By default, Armadillo prints warnings and messages associated with <i>std::logic_error</i>, <i>std::runtime_error</i> and <i>std::bad_alloc</i> exceptions -to the <i>std::cout</i> stream +By default, warnings and messages associated with exceptions are printed to the <i>std::cout</i> stream +<ul> +<li>the printing can be disabled by defining <a href="#config_hpp">ARMA_DONT_PRINT_ERRORS</a> before including the armadillo header</li> +<li>detailed information about errors is always reported via the base <i>std::exception</i> class</li> +</ul> </li> <br> <li><b>set_stream_err1()</b>: change the stream for messages associated with <i>std::logic_error</i> exceptions (eg. out of bounds accesses)</li> @@ -12871,10 +12865,6 @@ <li><b>get_stream_err2()</b>: get a reference to the stream for warnings and messages associated with <i>std::runtime_error</i> exceptions</li> <br> <li> -The printing of all errors and warnings can be disabled by defining <a href="#config_hpp">ARMA_DONT_PRINT_ERRORS</a> before including the armadillo header -</li> -<br> -<li> Examples: <ul> <pre> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/arma_version.hpp new/armadillo-6.100.1/include/armadillo_bits/arma_version.hpp --- old/armadillo-6.100.0/include/armadillo_bits/arma_version.hpp 2015-10-02 04:44:31.000000000 +0200 +++ new/armadillo-6.100.1/include/armadillo_bits/arma_version.hpp 2015-10-20 17:37:12.000000000 +0200 @@ -13,7 +13,7 @@ #define ARMA_VERSION_MAJOR 6 #define ARMA_VERSION_MINOR 100 -#define ARMA_VERSION_PATCH 0 +#define ARMA_VERSION_PATCH 1 #define ARMA_VERSION_NAME "Midnight Blue" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/config.hpp new/armadillo-6.100.1/include/armadillo_bits/config.hpp --- old/armadillo-6.100.0/include/armadillo_bits/config.hpp 2015-04-10 07:54:47.000000000 +0200 +++ new/armadillo-6.100.1/include/armadillo_bits/config.hpp 2015-10-19 09:02:56.000000000 +0200 @@ -132,13 +132,13 @@ #define ARMA_DEFAULT_OSTREAM std::cout #endif +#if !defined(ARMA_PRINT_ERRORS) #define ARMA_PRINT_ERRORS -//#define ARMA_PRINT_HDF5_ERRORS - +//// Comment out the above line if you don't want errors and warnings printed (eg. failed decompositions) +#endif -#if defined(ARMA_DONT_PRINT_ERRORS) - #undef ARMA_PRINT_ERRORS - #undef ARMA_PRINT_HDF5_ERRORS +#if !defined(ARMA_PRINT_HDF5_ERRORS) +// #define ARMA_PRINT_HDF5_ERRORS #endif #if defined(ARMA_DONT_USE_LAPACK) @@ -192,3 +192,12 @@ #if defined(ARMA_DONT_USE_HDF5) #undef ARMA_USE_HDF5 #endif + +#if defined(ARMA_DONT_PRINT_ERRORS) + #undef ARMA_PRINT_ERRORS +#endif + +#if defined(ARMA_DONT_PRINT_HDF5_ERRORS) + #undef ARMA_PRINT_HDF5_ERRORS +#endif + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/config.hpp.cmake new/armadillo-6.100.1/include/armadillo_bits/config.hpp.cmake --- old/armadillo-6.100.0/include/armadillo_bits/config.hpp.cmake 2015-04-10 07:54:47.000000000 +0200 +++ new/armadillo-6.100.1/include/armadillo_bits/config.hpp.cmake 2015-10-19 09:02:56.000000000 +0200 @@ -132,13 +132,13 @@ #define ARMA_DEFAULT_OSTREAM std::cout #endif +#if !defined(ARMA_PRINT_ERRORS) #define ARMA_PRINT_ERRORS -//#define ARMA_PRINT_HDF5_ERRORS - +//// Comment out the above line if you don't want errors and warnings printed (eg. failed decompositions) +#endif -#if defined(ARMA_DONT_PRINT_ERRORS) - #undef ARMA_PRINT_ERRORS - #undef ARMA_PRINT_HDF5_ERRORS +#if !defined(ARMA_PRINT_HDF5_ERRORS) +// #define ARMA_PRINT_HDF5_ERRORS #endif #if defined(ARMA_DONT_USE_LAPACK) @@ -192,3 +192,12 @@ #if defined(ARMA_DONT_USE_HDF5) #undef ARMA_USE_HDF5 #endif + +#if defined(ARMA_DONT_PRINT_ERRORS) + #undef ARMA_PRINT_ERRORS +#endif + +#if defined(ARMA_DONT_PRINT_HDF5_ERRORS) + #undef ARMA_PRINT_HDF5_ERRORS +#endif + diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/debug.hpp new/armadillo-6.100.1/include/armadillo_bits/debug.hpp --- old/armadillo-6.100.0/include/armadillo_bits/debug.hpp 2015-07-28 06:23:54.000000000 +0200 +++ new/armadillo-6.100.1/include/armadillo_bits/debug.hpp 2015-10-20 17:29:49.000000000 +0200 @@ -102,10 +102,6 @@ out << '\n'; out.flush(); } - #else - { - arma_ignore(x); - } #endif throw std::logic_error( std::string(x) ); @@ -160,10 +156,6 @@ out << '\n'; out.flush(); } - #else - { - arma_ignore(x); - } #endif if(hurl == true) @@ -301,10 +293,16 @@ void arma_warn(const bool state, const T1& x) { - if(state==true) + #if defined(ARMA_PRINT_ERRORS) + { + if(state==true) { get_stream_err2() << x << std::endl; } + } + #else { - get_stream_err2() << x << std::endl; + arma_ignore(state); + arma_ignore(x); } + #endif } @@ -315,10 +313,17 @@ void arma_warn(const bool state, const T1& x, const T2& y) { - if(state==true) + #if defined(ARMA_PRINT_ERRORS) { - get_stream_err2() << x << y << std::endl; + if(state==true) { get_stream_err2() << x << y << std::endl; } } + #else + { + arma_ignore(state); + arma_ignore(x); + arma_ignore(y); + } + #endif } @@ -329,10 +334,18 @@ void arma_warn(const bool state, const T1& x, const T2& y, const T3& z) { - if(state==true) + #if defined(ARMA_PRINT_ERRORS) + { + if(state==true) { get_stream_err2() << x << y << z << std::endl; } + } + #else { - get_stream_err2() << x << y << z << std::endl; + arma_ignore(state); + arma_ignore(x); + arma_ignore(y); + arma_ignore(z); } + #endif } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/fn_eig_gen.hpp new/armadillo-6.100.1/include/armadillo_bits/fn_eig_gen.hpp --- old/armadillo-6.100.0/include/armadillo_bits/fn_eig_gen.hpp 2013-12-18 07:28:44.000000000 +0100 +++ new/armadillo-6.100.1/include/armadillo_bits/fn_eig_gen.hpp 2015-10-20 17:35:33.000000000 +0200 @@ -190,10 +190,10 @@ { const uword n = eigval.n_elem; + eigvec.set_size(n,n); + if(n > 0) { - eigvec.set_size(n,n); - for(uword j=0; j<n; ++j) { if( (j < n-1) && (eigval[j] == std::conj(eigval[j+1])) ) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/fn_eig_pair.hpp new/armadillo-6.100.1/include/armadillo_bits/fn_eig_pair.hpp --- old/armadillo-6.100.0/include/armadillo_bits/fn_eig_pair.hpp 2013-12-18 07:28:44.000000000 +0100 +++ new/armadillo-6.100.1/include/armadillo_bits/fn_eig_pair.hpp 2015-10-21 04:56:50.000000000 +0200 @@ -173,10 +173,10 @@ { const uword n = eigval.n_elem; + eigvec.set_size(n,n); + if(n > 0) { - eigvec.set_size(n,n); - // from LAPACK docs: // If the j-th and (j+1)-th eigenvalues form a complex conjugate pair, then // v(j) = VR(:,j)+i*VR(:,j+1) and v(j+1) = VR(:,j)-i*VR(:,j+1). diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-6.100.0/include/armadillo_bits/sp_auxlib_meat.hpp new/armadillo-6.100.1/include/armadillo_bits/sp_auxlib_meat.hpp --- old/armadillo-6.100.0/include/armadillo_bits/sp_auxlib_meat.hpp 2015-09-03 07:54:42.000000000 +0200 +++ new/armadillo-6.100.1/include/armadillo_bits/sp_auxlib_meat.hpp 2015-10-21 05:44:36.000000000 +0200 @@ -258,7 +258,7 @@ // ?geev (see auxlib::eig_gen()). if((i < n_eigvals - 1) && (eigval[i] == std::conj(eigval[i + 1]))) { - for (uword j = 0; j < n; ++j) + for (uword j = 0; j < uword(n); ++j) { eigvec.at(j, i) = std::complex<T>(z[n * i + j], z[n * (i + 1) + j]); eigvec.at(j, i + 1) = std::complex<T>(z[n * i + j], -z[n * (i + 1) + j]); @@ -269,7 +269,7 @@ if((i == n_eigvals - 1) && (std::complex<T>(eigval[i]).imag() != 0.0)) { // We don't have the matched conjugate eigenvalue. - for (uword j = 0; j < n; ++j) + for (uword j = 0; j < uword(n); ++j) { eigvec.at(j, i) = std::complex<T>(z[n * i + j], z[n * (i + 1) + j]); } @@ -277,7 +277,7 @@ else { // The eigenvector is entirely real. - for (uword j = 0; j < n; ++j) + for (uword j = 0; j < uword(n); ++j) { eigvec.at(j, i) = std::complex<T>(z[n * i + j], T(0)); }
