Hello community, here is the log from the commit of package armadillo for openSUSE:Leap:15.2 checked in at 2020-05-23 16:06:52 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Leap:15.2/armadillo (Old) and /work/SRC/openSUSE:Leap:15.2/.armadillo.new.2738 (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "armadillo" Sat May 23 16:06:52 2020 rev:25 rq:808132 version:9.880.1 Changes: -------- --- /work/SRC/openSUSE:Leap:15.2/armadillo/armadillo.changes 2020-05-12 11:42:38.825035968 +0200 +++ /work/SRC/openSUSE:Leap:15.2/.armadillo.new.2738/armadillo.changes 2020-05-23 16:06:52.900983799 +0200 @@ -1,0 +2,9 @@ +Sun May 17 18:10:12 UTC 2020 - Atri Bhattacharya <[email protected]> + +- Update to version 9.880.1: + * Expanded qr() to optionally use pivoted decomposition. + * Updated physical constants to NIST 2018 CODATA values. + * Added ARMA_DONT_USE_CXX11_MUTEX confguration option to disable + use of std::mutex. + +------------------------------------------------------------------- Old: ---- armadillo-9.870.2.tar.xz New: ---- armadillo-9.880.1.tar.xz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ armadillo.spec ++++++ --- /var/tmp/diff_new_pack.paFBED/_old 2020-05-23 16:06:53.316984691 +0200 +++ /var/tmp/diff_new_pack.paFBED/_new 2020-05-23 16:06:53.324984708 +0200 @@ -18,7 +18,7 @@ %define soname libarmadillo9 Name: armadillo -Version: 9.870.2 +Version: 9.880.1 Release: 0 Summary: C++ matrix library with interfaces to LAPACK and ATLAS License: Apache-2.0 ++++++ armadillo-9.870.2.tar.xz -> armadillo-9.880.1.tar.xz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/CMakeLists.txt new/armadillo-9.880.1/CMakeLists.txt --- old/armadillo-9.870.2/CMakeLists.txt 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/CMakeLists.txt 2016-06-16 18:21:01.000000000 +0200 @@ -142,6 +142,12 @@ ## Example use on the command line: ## cmake -D ALLOW_BLAS_LAPACK_MACOS=true . +option(BUILD_SMOKE_TEST "Build a smoke test" OFF) +## Example use on the command line: +## cmake -D BUILD_SMOKE_TEST=true . +## make +## ctest + if(WIN32) message(STATUS "") @@ -167,7 +173,10 @@ message(STATUS "DETECT_HDF5 = ${DETECT_HDF5}" ) message(STATUS "ALLOW_OPENBLAS_MACOS = ${ALLOW_OPENBLAS_MACOS}" ) message(STATUS "ALLOW_BLAS_LAPACK_MACOS = ${ALLOW_BLAS_LAPACK_MACOS}" ) +message(STATUS "BUILD_SMOKE_TEST = ${BUILD_SMOKE_TEST}" ) +message(STATUS "") +message(STATUS "*** Looking for external libraries") ## ## Find LAPACK and BLAS libraries, or their optimised versions @@ -602,3 +611,12 @@ configure_file(${PROJECT_BINARY_DIR}/tmp/misc/armadillo.pc.in "${PROJECT_BINARY_DIR}/tmp/misc/armadillo.pc" @ONLY) install(FILES "${PROJECT_BINARY_DIR}/tmp/misc/armadillo.pc" DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig) + + +# smoke test + +if(BUILD_SMOKE_TEST) + message(STATUS "*** configuring smoke_test") + enable_testing() + add_subdirectory(smoke_test) +endif() diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/docs.html new/armadillo-9.880.1/docs.html --- old/armadillo-9.870.2/docs.html 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/docs.html 2016-06-16 18:21:01.000000000 +0200 @@ -149,7 +149,7 @@ <a class="noprint" style="display:scroll; position:fixed; bottom:5px; right:5px;" href="#top"><font size=-1>[top]</font></a> <a name="top"></a> -<big><b>API Documentation for Armadillo 9.870</b></big> +<big><b>API Documentation for Armadillo 9.880</b></big> <br> <br> <br> @@ -12567,14 +12567,29 @@ <div class="pagebreak"></div><div class="noprint"><hr class="greyline"><br></div> <a name="qr"></a> -<b>qr( Q, R, X )</b> +<table> +<tr><td><b>qr( Q, R, X )</b></td><td> </td><td>(form 1)</td></tr> +<tr><td><b>qr( Q, R, P, X, "vector" )</b></td><td> </td><td>(form 2)</td></tr> +<tr><td><b>qr( Q, R, P, X, "matrix" )</b></td><td> </td><td>(form 3)</td></tr> +</table> <ul> <li> -Decomposition of <i>X</i> into an orthogonal matrix <i>Q</i> and a right triangular matrix <i>R</i>, such that <i>Q*R = X</i> +Decomposition of <i>X</i> into an orthogonal matrix <i>Q</i> and a right triangular matrix <i>R</i>, +with an optional permutation matrix/vector <i>P</i> +<ul> +<li>form 1: decomposition has the form <i>Q*R = X</i></li> +<li>form 2: <i>P</i> is permutation vector with type <a href="#Col">uvec</a>; decomposition has the form <i>Q*R = X.cols(P)</i></li> +<li>form 3: <i>P</i> is permutation matrix with type <a href="#Mat">umat</a>; decomposition has the form <i>Q*R = X*P</i></li> +</ul> </li> <br> <li> -If the decomposition fails, <i>Q</i> and <i>R</i> are reset and the function returns a bool set to <i>false</i> (exception is not thrown) +If <i>P</i> is specified, a column pivoting decomposition is used; +the diagonal entries of <i>R</i> are ordered from largest to smallest magnitude +</li> +<br> +<li> +If the decomposition fails, <i>Q</i>, <i>R</i> and <i>P</i> are reset and the function returns a bool set to <i>false</i> (exception is not thrown) </li> <br> <li> @@ -12582,9 +12597,17 @@ <ul> <pre> mat X = randu<mat>(5,5); -mat Q, R; -qr(Q,R,X); +mat Q; +mat R; + +qr(Q, R, X); + +uvec P_vec; +umat P_mat; + +qr(Q, R, P_vec, X, "vector"); +qr(Q, R, P_mat, X, "matrix"); </pre> </ul> </li> @@ -12625,9 +12648,11 @@ <ul> <pre> mat X = randu<mat>(6,5); -mat Q, R; -qr_econ(Q,R,X); +mat Q; +mat R; + +qr_econ(Q, R, X); </pre> </ul> </li> @@ -16705,7 +16730,7 @@ <br> <li> The physical constants were mainly taken from -<a href="http://physics.nist.gov/cuu/Constants";>NIST 2014 CODATA values</a>, +<a href="http://physics.nist.gov/cuu/Constants";>NIST 2018 CODATA values</a>, and some from <a href="http://www.wolframalpha.com";>WolframAlpha</a> (as of 2009-06-23) </li> @@ -18147,7 +18172,29 @@ </td> <td style="vertical-align: top;"> -Disable use of C++11 features; overrides <i>ARMA_USE_CXX11</i> +Disable use of all C++11 features; overrides <i>ARMA_USE_CXX11</i> + </td> + </tr> + <tr> + <td style="vertical-align: top;"> + + </td> + <td style="vertical-align: top;"> + + </td> + <td style="vertical-align: top;"> + + </td> + </tr> + <tr> + <td style="vertical-align: top;"> +<code>ARMA_DONT_USE_CXX11_MUTEX</code> + </td> + <td style="vertical-align: top;"> + + </td> + <td style="vertical-align: top;"> +Disable use of only <i>std::mutex</i> in C++11; applicable if your compiler and/or environment doesn't support <i>std::mutex</i> </td> </tr> <tr> @@ -18838,6 +18885,15 @@ +<a name="version_9880"></a> +<li>Version 9.880: +<ul> +<li>expanded <a href="#qr">qr()</a> to optionally use pivoted decomposition</li> +<li>updated <a href="#constants">physical constants</a> to NIST 2018 CODATA values</li> +<li>added <code>ARMA_DONT_USE_CXX11_MUTEX</code> <a href="#config_hpp">confguration option</a> to disable use of <i>std::mutex</i></li> +</ul> +</li> +<br> <a name="version_9870"></a> <li>Version 9.870: <ul> diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo new/armadillo-9.880.1/include/armadillo --- old/armadillo-9.870.2/include/armadillo 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo 2016-06-16 18:21:01.000000000 +0200 @@ -60,6 +60,10 @@ #include <random> #include <functional> #include <chrono> +#endif + + +#if defined(ARMA_USE_CXX11_MUTEX) #include <mutex> #include <atomic> #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/MapMat_meat.hpp new/armadillo-9.880.1/include/armadillo_bits/MapMat_meat.hpp --- old/armadillo-9.870.2/include/armadillo_bits/MapMat_meat.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/MapMat_meat.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -1204,7 +1204,7 @@ (*this).set(in_val); } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) { s_parent.cache_mutex.lock(); @@ -1239,7 +1239,7 @@ (*this).add(in_val); } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) { s_parent.cache_mutex.lock(); @@ -1274,7 +1274,7 @@ (*this).sub(in_val); } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) { s_parent.cache_mutex.lock(); @@ -1307,7 +1307,7 @@ (*this).mul(in_val); } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) { s_parent.cache_mutex.lock(); @@ -1340,7 +1340,7 @@ (*this).div(in_val); } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) { s_parent.cache_mutex.lock(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/SpBase_meat.hpp new/armadillo-9.880.1/include/armadillo_bits/SpBase_meat.hpp --- old/armadillo-9.870.2/include/armadillo_bits/SpBase_meat.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/SpBase_meat.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -414,7 +414,7 @@ if(P.get_n_elem() == 0) { return false; } - if( (tol == T(0)) && (P.get_n_nonzero() == 0) ) { return true; } + if(P.get_n_nonzero() == 0) { return true; } if(is_SpMat<typename SpProxy<derived>::stored_type>::value) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/SpMat_bones.hpp new/armadillo-9.880.1/include/armadillo_bits/SpMat_bones.hpp --- old/armadillo-9.870.2/include/armadillo_bits/SpMat_bones.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/SpMat_bones.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -681,7 +681,7 @@ // 1: CSC needs to be updated from cache (ie. cache has more recent data) // 2: no update required (ie. CSC and cache contain the same data) - #if defined(ARMA_USE_CXX11) + #if defined(ARMA_USE_CXX11_MUTEX) arma_aligned mutable std::mutex cache_mutex; #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/SpMat_meat.hpp new/armadillo-9.880.1/include/armadillo_bits/SpMat_meat.hpp --- old/armadillo-9.870.2/include/armadillo_bits/SpMat_meat.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/SpMat_meat.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -5206,7 +5206,7 @@ init_done = true; } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) if(x.sync_state == 1) { x.cache_mutex.lock(); @@ -6816,7 +6816,7 @@ } } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) { if(sync_state == 0) { @@ -6869,7 +6869,7 @@ sync_csc_simple(); } } - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) if(sync_state == 1) { cache_mutex.lock(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/arma_config.hpp new/armadillo-9.880.1/include/armadillo_bits/arma_config.hpp --- old/armadillo-9.870.2/include/armadillo_bits/arma_config.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/arma_config.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -135,6 +135,13 @@ #endif + #if defined(ARMA_USE_CXX11_MUTEX) + static const bool cxx11_mutex = true; + #else + static const bool cxx11_mutex = false; + #endif + + #if (defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 200112L)) static const bool posix = true; #else diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/arma_forward.hpp new/armadillo-9.880.1/include/armadillo_bits/arma_forward.hpp --- old/armadillo-9.870.2/include/armadillo_bits/arma_forward.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/arma_forward.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -269,7 +269,7 @@ { #if defined(ARMA_USE_OPENMP) int state; - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) std::atomic<int> state; #else int state; @@ -288,7 +288,7 @@ #if defined(ARMA_USE_OPENMP) #pragma omp atomic read out = state; - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) out = state.load(); #else out = state; @@ -304,7 +304,7 @@ #if defined(ARMA_USE_OPENMP) #pragma omp atomic write state = in_state; - #elif defined(ARMA_USE_CXX11) + #elif defined(ARMA_USE_CXX11_MUTEX) state.store(in_state); #else state = in_state; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/arma_version.hpp new/armadillo-9.880.1/include/armadillo_bits/arma_version.hpp --- old/armadillo-9.870.2/include/armadillo_bits/arma_version.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/arma_version.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -20,9 +20,9 @@ #define ARMA_VERSION_MAJOR 9 -#define ARMA_VERSION_MINOR 870 -#define ARMA_VERSION_PATCH 2 -#define ARMA_VERSION_NAME "Roasted Mocha Retox" +#define ARMA_VERSION_MINOR 880 +#define ARMA_VERSION_PATCH 1 +#define ARMA_VERSION_NAME "Roasted Mocha Detox" diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/auxlib_bones.hpp new/armadillo-9.880.1/include/armadillo_bits/auxlib_bones.hpp --- old/armadillo-9.870.2/include/armadillo_bits/auxlib_bones.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/auxlib_bones.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -156,14 +156,14 @@ template<typename eT> inline static bool chol_band_common(Mat<eT>& X, const uword KD, const uword layout); - + // // hessenberg decomposition - + template<typename eT, typename T1> inline static bool hess(Mat<eT>& H, const Base<eT,T1>& X, Col<eT>& tao); - - + + // // qr @@ -173,6 +173,12 @@ template<typename eT, typename T1> inline static bool qr_econ(Mat<eT>& Q, Mat<eT>& R, const Base<eT,T1>& X); + template<typename eT, typename T1> + inline static bool qr_pivot(Mat<eT>& Q, Mat<eT>& R, Mat<uword>& P, const Base<eT,T1>& X); + + template<typename T, typename T1> + inline static bool qr_pivot(Mat< std::complex<T> >& Q, Mat< std::complex<T> >& R, Mat<uword>& P, const Base<std::complex<T>,T1>& X); + // // svd diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/auxlib_meat.hpp new/armadillo-9.880.1/include/armadillo_bits/auxlib_meat.hpp --- old/armadillo-9.870.2/include/armadillo_bits/auxlib_meat.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/auxlib_meat.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -2332,6 +2332,195 @@ template<typename eT, typename T1> inline bool +auxlib::qr_pivot(Mat<eT>& Q, Mat<eT>& R, Mat<uword>& P, const Base<eT,T1>& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + R = X.get_ref(); + + const uword R_n_rows = R.n_rows; + const uword R_n_cols = R.n_cols; + + if(R.is_empty()) + { + Q.eye(R_n_rows, R_n_rows); + + P.set_size(R_n_cols, 1); + + for(uword col=0; col < R_n_cols; ++col) { P.at(col) = col; } + + return true; + } + + arma_debug_assert_blas_size(R); + + blas_int m = static_cast<blas_int>(R_n_rows); + blas_int n = static_cast<blas_int>(R_n_cols); + blas_int lwork = 0; + blas_int lwork_min = (std::max)(blas_int(3*n + 1), (std::max)(m,n)); // take into account requirements of geqp3() and orgqr() + blas_int k = (std::min)(m,n); + blas_int info = 0; + + podarray<eT> tau( static_cast<uword>(k) ); + podarray<blas_int> jpvt( R_n_cols ); + + jpvt.zeros(); + + eT work_query[2]; + blas_int lwork_query = -1; + + arma_extra_debug_print("lapack::geqp3()"); + lapack::geqp3(&m, &n, R.memptr(), &m, jpvt.memptr(), tau.memptr(), &work_query[0], &lwork_query, &info); + + if(info != 0) { return false; } + + blas_int lwork_proposed = static_cast<blas_int>( access::tmp_real(work_query[0]) ); + + lwork = (std::max)(lwork_proposed, lwork_min); + + podarray<eT> work( static_cast<uword>(lwork) ); + + arma_extra_debug_print("lapack::geqp3()"); + lapack::geqp3(&m, &n, R.memptr(), &m, jpvt.memptr(), tau.memptr(), work.memptr(), &lwork, &info); + + if(info != 0) { return false; } + + Q.set_size(R_n_rows, R_n_rows); + + arrayops::copy( Q.memptr(), R.memptr(), (std::min)(Q.n_elem, R.n_elem) ); + + // + // construct R and P + + P.set_size(R_n_cols, 1); + + for(uword col=0; col < R_n_cols; ++col) + { + for(uword row=(col+1); row < R_n_rows; ++row) { R.at(row,col) = eT(0); } + + P.at(col) = jpvt[col] - 1; // take into account that Fortran counts from 1 + } + + arma_extra_debug_print("lapack::orgqr()"); + lapack::orgqr(&m, &m, &k, Q.memptr(), &m, tau.memptr(), work.memptr(), &lwork, &info); + + return (info == 0); + } + #else + { + arma_ignore(Q); + arma_ignore(R); + arma_ignore(P); + arma_ignore(X); + arma_stop_logic_error("qr(): use of LAPACK must be enabled"); + return false; + } + #endif + } + + + +template<typename T, typename T1> +inline +bool +auxlib::qr_pivot(Mat< std::complex<T> >& Q, Mat< std::complex<T> >& R, Mat<uword>& P, const Base<std::complex<T>,T1>& X) + { + arma_extra_debug_sigprint(); + + #if defined(ARMA_USE_LAPACK) + { + typedef typename std::complex<T> eT; + + R = X.get_ref(); + + const uword R_n_rows = R.n_rows; + const uword R_n_cols = R.n_cols; + + if(R.is_empty()) + { + Q.eye(R_n_rows, R_n_rows); + + P.set_size(R_n_cols, 1); + + for(uword col=0; col < R_n_cols; ++col) { P.at(col) = col; } + + return true; + } + + arma_debug_assert_blas_size(R); + + blas_int m = static_cast<blas_int>(R_n_rows); + blas_int n = static_cast<blas_int>(R_n_cols); + blas_int lwork = 0; + blas_int lwork_min = (std::max)(blas_int(3*n + 1), (std::max)(m,n)); // take into account requirements of geqp3() and ungqr() + blas_int k = (std::min)(m,n); + blas_int info = 0; + + podarray<eT> tau( static_cast<uword>(k) ); + podarray< T> rwork( 2*R_n_cols ); + podarray<blas_int> jpvt( R_n_cols ); + + jpvt.zeros(); + + eT work_query[2]; + blas_int lwork_query = -1; + + arma_extra_debug_print("lapack::geqp3()"); + lapack::cx_geqp3(&m, &n, R.memptr(), &m, jpvt.memptr(), tau.memptr(), &work_query[0], &lwork_query, rwork.memptr(), &info); + + if(info != 0) { return false; } + + blas_int lwork_proposed = static_cast<blas_int>( access::tmp_real(work_query[0]) ); + + lwork = (std::max)(lwork_proposed, lwork_min); + + podarray<eT> work( static_cast<uword>(lwork) ); + + arma_extra_debug_print("lapack::geqp3()"); + lapack::cx_geqp3(&m, &n, R.memptr(), &m, jpvt.memptr(), tau.memptr(), work.memptr(), &lwork, rwork.memptr(), &info); + + if(info != 0) { return false; } + + Q.set_size(R_n_rows, R_n_rows); + + arrayops::copy( Q.memptr(), R.memptr(), (std::min)(Q.n_elem, R.n_elem) ); + + // + // construct R and P + + P.set_size(R_n_cols, 1); + + for(uword col=0; col < R_n_cols; ++col) + { + for(uword row=(col+1); row < R_n_rows; ++row) { R.at(row,col) = eT(0); } + + P.at(col) = jpvt[col] - 1; // take into account that Fortran counts from 1 + } + + arma_extra_debug_print("lapack::ungqr()"); + lapack::ungqr(&m, &m, &k, Q.memptr(), &m, tau.memptr(), work.memptr(), &lwork, &info); + + return (info == 0); + } + #else + { + arma_ignore(Q); + arma_ignore(R); + arma_ignore(P); + arma_ignore(X); + arma_stop_logic_error("qr(): use of LAPACK must be enabled"); + return false; + } + #endif + } + + + +template<typename eT, typename T1> +inline +bool auxlib::svd(Col<eT>& S, const Base<eT,T1>& X, uword& X_n_rows, uword& X_n_cols) { arma_extra_debug_sigprint(); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/config.hpp new/armadillo-9.880.1/include/armadillo_bits/config.hpp --- old/armadillo-9.870.2/include/armadillo_bits/config.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/config.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -101,10 +101,15 @@ #if !defined(ARMA_USE_CXX11) // #define ARMA_USE_CXX11 -//// Uncomment the above line to forcefully enable use of C++11 features (eg. initialiser lists). +//// Uncomment the above line to forcefully enable use of C++11 features. //// Note that ARMA_USE_CXX11 is automatically enabled when a C++11 compiler is detected. #endif +#if defined(ARMA_USE_CXX11) + #define ARMA_USE_CXX11_MUTEX + //// Comment out the above line to disable use of std::mutex in C++11 +#endif + #if !defined(ARMA_USE_OPENMP) // #define ARMA_USE_OPENMP //// Uncomment the above line to forcefully enable use of OpenMP for parallelisation. @@ -249,9 +254,14 @@ #if defined(ARMA_DONT_USE_CXX11) #undef ARMA_USE_CXX11 + #undef ARMA_USE_CXX11_MUTEX #undef ARMA_USE_EXTERN_CXX11_RNG #endif +#if defined(ARMA_DONT_USE_CXX11_MUTEX) + #undef ARMA_USE_CXX11_MUTEX +#endif + #if defined(ARMA_DONT_USE_OPENMP) #undef ARMA_USE_OPENMP #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/config.hpp.cmake new/armadillo-9.880.1/include/armadillo_bits/config.hpp.cmake --- old/armadillo-9.870.2/include/armadillo_bits/config.hpp.cmake 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/config.hpp.cmake 2016-06-16 18:21:01.000000000 +0200 @@ -101,10 +101,15 @@ #if !defined(ARMA_USE_CXX11) // #define ARMA_USE_CXX11 -//// Uncomment the above line to forcefully enable use of C++11 features (eg. initialiser lists). +//// Uncomment the above line to forcefully enable use of C++11 features. //// Note that ARMA_USE_CXX11 is automatically enabled when a C++11 compiler is detected. #endif +#if defined(ARMA_USE_CXX11) + #define ARMA_USE_CXX11_MUTEX + //// Comment out the above line to disable use of std::mutex in C++11 +#endif + #if !defined(ARMA_USE_OPENMP) // #define ARMA_USE_OPENMP //// Uncomment the above line to forcefully enable use of OpenMP for parallelisation. @@ -249,9 +254,14 @@ #if defined(ARMA_DONT_USE_CXX11) #undef ARMA_USE_CXX11 + #undef ARMA_USE_CXX11_MUTEX #undef ARMA_USE_EXTERN_CXX11_RNG #endif +#if defined(ARMA_DONT_USE_CXX11_MUTEX) + #undef ARMA_USE_CXX11_MUTEX +#endif + #if defined(ARMA_DONT_USE_OPENMP) #undef ARMA_USE_OPENMP #endif diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/constants.hpp new/armadillo-9.880.1/include/armadillo_bits/constants.hpp --- old/armadillo-9.870.2/include/armadillo_bits/constants.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/constants.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -187,35 +187,35 @@ template<typename eT> const eT Datum<eT>::nan = priv::Datum_helper::nan<eT>(); template<typename eT> const eT Datum<eT>::inf = priv::Datum_helper::inf<eT>(); -template<typename eT> const eT Datum<eT>::m_u = eT(1.660539040e-27); -template<typename eT> const eT Datum<eT>::N_A = eT(6.022140857e23); -template<typename eT> const eT Datum<eT>::k = eT(1.38064852e-23); -template<typename eT> const eT Datum<eT>::k_evk = eT(8.6173303e-5); -template<typename eT> const eT Datum<eT>::a_0 = eT(0.52917721067e-10); -template<typename eT> const eT Datum<eT>::mu_B = eT(927.4009994e-26); -template<typename eT> const eT Datum<eT>::Z_0 = eT(376.730313461771); -template<typename eT> const eT Datum<eT>::G_0 = eT(7.7480917310e-5); -template<typename eT> const eT Datum<eT>::k_e = eT(8.9875517873681764e9); -template<typename eT> const eT Datum<eT>::eps_0 = eT(8.85418781762039e-12); -template<typename eT> const eT Datum<eT>::m_e = eT(9.10938356e-31); -template<typename eT> const eT Datum<eT>::eV = eT(1.6021766208e-19); -template<typename eT> const eT Datum<eT>::ec = eT(1.6021766208e-19); -template<typename eT> const eT Datum<eT>::F = eT(96485.33289); -template<typename eT> const eT Datum<eT>::alpha = eT(7.2973525664e-3); -template<typename eT> const eT Datum<eT>::alpha_inv = eT(137.035999139); -template<typename eT> const eT Datum<eT>::K_J = eT(483597.8525e9); -template<typename eT> const eT Datum<eT>::mu_0 = eT(1.25663706143592e-06); -template<typename eT> const eT Datum<eT>::phi_0 = eT(2.067833667e-15); -template<typename eT> const eT Datum<eT>::R = eT(8.3144598); -template<typename eT> const eT Datum<eT>::G = eT(6.67408e-11); -template<typename eT> const eT Datum<eT>::h = eT(6.626070040e-34); -template<typename eT> const eT Datum<eT>::h_bar = eT(1.054571800e-34); -template<typename eT> const eT Datum<eT>::m_p = eT(1.672621898e-27); -template<typename eT> const eT Datum<eT>::R_inf = eT(10973731.568508); +template<typename eT> const eT Datum<eT>::m_u = eT(1.66053906660e-27); +template<typename eT> const eT Datum<eT>::N_A = eT(6.02214076e23); +template<typename eT> const eT Datum<eT>::k = eT(1.380649e-23); +template<typename eT> const eT Datum<eT>::k_evk = eT(8.617333262e-5); +template<typename eT> const eT Datum<eT>::a_0 = eT(5.29177210903e-11); +template<typename eT> const eT Datum<eT>::mu_B = eT(9.2740100783e-24); +template<typename eT> const eT Datum<eT>::Z_0 = eT(376.730313668); +template<typename eT> const eT Datum<eT>::G_0 = eT(7.748091729e-5); +template<typename eT> const eT Datum<eT>::k_e = eT(8.9875517923e9); +template<typename eT> const eT Datum<eT>::eps_0 = eT(8.8541878128e-12); +template<typename eT> const eT Datum<eT>::m_e = eT(9.1093837015e-31); +template<typename eT> const eT Datum<eT>::eV = eT(1.602176634e-19); +template<typename eT> const eT Datum<eT>::ec = eT(1.602176634e-19); +template<typename eT> const eT Datum<eT>::F = eT(96485.33212); +template<typename eT> const eT Datum<eT>::alpha = eT(7.2973525693e-3); +template<typename eT> const eT Datum<eT>::alpha_inv = eT(137.035999084); +template<typename eT> const eT Datum<eT>::K_J = eT(483597.8484e9); +template<typename eT> const eT Datum<eT>::mu_0 = eT(1.25663706212e-6); +template<typename eT> const eT Datum<eT>::phi_0 = eT(2.067833848e-15); +template<typename eT> const eT Datum<eT>::R = eT(8.314462618); +template<typename eT> const eT Datum<eT>::G = eT(6.67430e-11); +template<typename eT> const eT Datum<eT>::h = eT(6.62607015e-34); +template<typename eT> const eT Datum<eT>::h_bar = eT(1.054571817e-34); +template<typename eT> const eT Datum<eT>::m_p = eT(1.67262192369e-27); +template<typename eT> const eT Datum<eT>::R_inf = eT(10973731.568160); template<typename eT> const eT Datum<eT>::c_0 = eT(299792458.0); -template<typename eT> const eT Datum<eT>::sigma = eT(5.670367e-8); -template<typename eT> const eT Datum<eT>::R_k = eT(25812.8074555); -template<typename eT> const eT Datum<eT>::b = eT(2.8977729e-3); +template<typename eT> const eT Datum<eT>::sigma = eT(5.670374419e-8); +template<typename eT> const eT Datum<eT>::R_k = eT(25812.80745); +template<typename eT> const eT Datum<eT>::b = eT(2.897771955e-3); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/constants_old.hpp new/armadillo-9.880.1/include/armadillo_bits/constants_old.hpp --- old/armadillo-9.870.2/include/armadillo_bits/constants_old.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/constants_old.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -32,34 +32,34 @@ // and any smart compiler that does high-precision computation at compile-time //! ratio of any circle's circumference to its diameter - arma_deprecated static eT pi() { return eT(3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679); } // use datum::pi instead + arma_deprecated static eT pi() { return eT(Datum<eT>::pi); } // use datum::pi instead //! base of the natural logarithm - arma_deprecated static eT e() { return eT(2.7182818284590452353602874713526624977572470936999595749669676277240766303535475945713821785251664274); } // use datum::e instead + arma_deprecated static eT e() { return eT(Datum<eT>::e); } // use datum::e instead //! Euler's constant, aka Euler-Mascheroni constant - arma_deprecated static eT euler() { return eT(0.5772156649015328606065120900824024310421593359399235988057672348848677267776646709369470632917467495); } // use datum::euler instead + arma_deprecated static eT euler() { return eT(Datum<eT>::euler); } // use datum::euler instead //! golden ratio - arma_deprecated static eT gratio() { return eT(1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374); } // use datum::gratio instead + arma_deprecated static eT gratio() { return eT(Datum<eT>::gratio); } // use datum::gratio instead //! square root of 2 - arma_deprecated static eT sqrt2() { return eT(1.4142135623730950488016887242096980785696718753769480731766797379907324784621070388503875343276415727); } // use datum::sqrt2 instead + arma_deprecated static eT sqrt2() { return eT(Datum<eT>::sqrt2); } // use datum::sqrt2 instead //! the difference between 1 and the least value greater than 1 that is representable - arma_deprecated static eT eps() { return std::numeric_limits<eT>::epsilon(); } // use datum::eps instead + arma_deprecated static eT eps() { return eT(Datum<eT>::eps); } // use datum::eps instead //! log of the minimum representable value - arma_deprecated static eT log_min() { static const eT out = std::log(std::numeric_limits<eT>::min()); return out; } // use datum::log_min instead + arma_deprecated static eT log_min() { return eT(Datum<eT>::log_min); } // use datum::log_min instead //! log of the maximum representable value - arma_deprecated static eT log_max() { static const eT out = std::log(std::numeric_limits<eT>::max()); return out; } // use datum::log_max instead + arma_deprecated static eT log_max() { return eT(Datum<eT>::log_max); } // use datum::log_max instead //! "not a number" - arma_deprecated static eT nan() { return priv::Datum_helper::nan<eT>(); } // use datum::nan instead + arma_deprecated static eT nan() { return eT(Datum<eT>::nan); } // use datum::nan instead //! infinity - arma_deprecated static eT inf() { return priv::Datum_helper::inf<eT>(); } // use datum::inf instead + arma_deprecated static eT inf() { return eT(Datum<eT>::inf); } // use datum::inf instead }; @@ -74,91 +74,91 @@ public: //! atomic mass constant (in kg) - arma_deprecated static eT m_u() { return eT(1.660539040e-27); } + arma_deprecated static eT m_u() { return eT(Datum<eT>::m_u); } //! Avogadro constant - arma_deprecated static eT N_A() { return eT(6.022140857e23); } + arma_deprecated static eT N_A() { return eT(Datum<eT>::N_A); } //! Boltzmann constant (in joules per kelvin) - arma_deprecated static eT k() { return eT(1.38064852e-23); } + arma_deprecated static eT k() { return eT(Datum<eT>::k); } //! Boltzmann constant (in eV/K) - arma_deprecated static eT k_evk() { return eT(8.6173303e-5); } + arma_deprecated static eT k_evk() { return eT(Datum<eT>::k_evk); } //! Bohr radius (in meters) - arma_deprecated static eT a_0() { return eT(0.52917721067e-10); } + arma_deprecated static eT a_0() { return eT(Datum<eT>::a_0); } //! Bohr magneton - arma_deprecated static eT mu_B() { return eT(927.4009994e-26); } + arma_deprecated static eT mu_B() { return eT(Datum<eT>::mu_B); } //! characteristic impedance of vacuum (in ohms) - arma_deprecated static eT Z_0() { return eT(376.730313461771); } + arma_deprecated static eT Z_0() { return eT(Datum<eT>::Z_0); } //! conductance quantum (in siemens) - arma_deprecated static eT G_0() { return eT(7.7480917310e-5); } + arma_deprecated static eT G_0() { return eT(Datum<eT>::G_0); } //! Coulomb's constant (in meters per farad) - arma_deprecated static eT k_e() { return eT(8.9875517873681764e9); } + arma_deprecated static eT k_e() { return eT(Datum<eT>::k_e); } //! electric constant (in farads per meter) - arma_deprecated static eT eps_0() { return eT(8.85418781762039e-12); } + arma_deprecated static eT eps_0() { return eT(Datum<eT>::eps_0); } //! electron mass (in kg) - arma_deprecated static eT m_e() { return eT(9.10938356e-31); } + arma_deprecated static eT m_e() { return eT(Datum<eT>::m_e); } //! electron volt (in joules) - arma_deprecated static eT eV() { return eT(1.6021766208e-19); } + arma_deprecated static eT eV() { return eT(Datum<eT>::eV); } //! elementary charge (in coulombs) - arma_deprecated static eT e() { return eT(1.6021766208e-19); } + arma_deprecated static eT e() { return eT(Datum<eT>::ec); } //! Faraday constant (in coulombs) - arma_deprecated static eT F() { return eT(96485.33289); } + arma_deprecated static eT F() { return eT(Datum<eT>::F); } //! fine-structure constant - arma_deprecated static eT alpha() { return eT(7.2973525664e-3); } + arma_deprecated static eT alpha() { return eT(Datum<eT>::alpha); } //! inverse fine-structure constant - arma_deprecated static eT alpha_inv() { return eT(137.035999139); } + arma_deprecated static eT alpha_inv() { return eT(Datum<eT>::alpha_inv); } //! Josephson constant - arma_deprecated static eT K_J() { return eT(483597.8525e9); } + arma_deprecated static eT K_J() { return eT(Datum<eT>::K_J); } //! magnetic constant (in henries per meter) - arma_deprecated static eT mu_0() { return eT(1.25663706143592e-06); } + arma_deprecated static eT mu_0() { return eT(Datum<eT>::mu_0); } //! magnetic flux quantum (in webers) - arma_deprecated static eT phi_0() { return eT(2.067833667e-15); } + arma_deprecated static eT phi_0() { return eT(Datum<eT>::phi_0); } //! molar gas constant (in joules per mole kelvin) - arma_deprecated static eT R() { return eT(8.3144598); } + arma_deprecated static eT R() { return eT(Datum<eT>::R); } //! Newtonian constant of gravitation (in newton square meters per kilogram squared) - arma_deprecated static eT G() { return eT(6.67408e-11); } + arma_deprecated static eT G() { return eT(Datum<eT>::G); } //! Planck constant (in joule seconds) - arma_deprecated static eT h() { return eT(6.626070040e-34); } + arma_deprecated static eT h() { return eT(Datum<eT>::h); } //! Planck constant over 2 pi, aka reduced Planck constant (in joule seconds) - arma_deprecated static eT h_bar() { return eT(1.054571800e-34); } + arma_deprecated static eT h_bar() { return eT(Datum<eT>::h_bar); } //! proton mass (in kg) - arma_deprecated static eT m_p() { return eT(1.672621898e-27); } + arma_deprecated static eT m_p() { return eT(Datum<eT>::m_p); } //! Rydberg constant (in reciprocal meters) - arma_deprecated static eT R_inf() { return eT(10973731.568508); } + arma_deprecated static eT R_inf() { return eT(Datum<eT>::R_inf); } //! speed of light in vacuum (in meters per second) - arma_deprecated static eT c_0() { return eT(299792458.0); } + arma_deprecated static eT c_0() { return eT(Datum<eT>::c_0); } //! Stefan-Boltzmann constant - arma_deprecated static eT sigma() { return eT(5.670367e-8); } + arma_deprecated static eT sigma() { return eT(Datum<eT>::sigma); } //! von Klitzing constant (in ohms) - arma_deprecated static eT R_k() { return eT(25812.8074555); } + arma_deprecated static eT R_k() { return eT(Datum<eT>::R_k); } //! Wien wavelength displacement law constant - arma_deprecated static eT b() { return eT(2.8977729e-3); } + arma_deprecated static eT b() { return eT(Datum<eT>::b); } }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/debug.hpp new/armadillo-9.880.1/include/armadillo_bits/debug.hpp --- old/armadillo-9.870.2/include/armadillo_bits/debug.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/debug.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -1318,6 +1318,7 @@ out << "@ arma_config::wrapper = " << arma_config::wrapper << '\n'; out << "@ arma_config::cxx11 = " << arma_config::cxx11 << '\n'; + out << "@ arma_config::cxx11_mutex = " << arma_config::cxx11_mutex << '\n'; out << "@ arma_config::posix = " << arma_config::posix << '\n'; out << "@ arma_config::openmp = " << arma_config::openmp << '\n'; out << "@ arma_config::lapack = " << arma_config::lapack << '\n'; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/def_lapack.hpp new/armadillo-9.880.1/include/armadillo_bits/def_lapack.hpp --- old/armadillo-9.870.2/include/armadillo_bits/def_lapack.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/def_lapack.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -96,6 +96,11 @@ #define arma_cgeqrf cgeqrf #define arma_zgeqrf zgeqrf + #define arma_sgeqp3 sgeqp3 + #define arma_dgeqp3 dgeqp3 + #define arma_cgeqp3 cgeqp3 + #define arma_zgeqp3 zgeqp3 + #define arma_sorgqr sorgqr #define arma_dorgqr dorgqr @@ -325,6 +330,11 @@ #define arma_cgeqrf CGEQRF #define arma_zgeqrf ZGEQRF + #define arma_sgeqp3 SGEQP3 + #define arma_dgeqp3 DGEQP3 + #define arma_cgeqp3 CGEQP3 + #define arma_zgeqp3 ZGEQP3 + #define arma_sorgqr SORGQR #define arma_dorgqr DORGQR @@ -597,6 +607,14 @@ void arma_fortran(arma_cgeqrf)(const blas_int* m, const blas_int* n, blas_cxf* a, const blas_int* lda, blas_cxf* tau, blas_cxf* work, const blas_int* lwork, blas_int* info); void arma_fortran(arma_zgeqrf)(const blas_int* m, const blas_int* n, blas_cxd* a, const blas_int* lda, blas_cxd* tau, blas_cxd* work, const blas_int* lwork, blas_int* info); + // QR decomposition with pivoting (real matrices) + void arma_fortran(arma_sgeqp3)(const blas_int* m, const blas_int* n, float* a, const blas_int* lda, blas_int* jpvt, float* tau, float* work, const blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgeqp3)(const blas_int* m, const blas_int* n, double* a, const blas_int* lda, blas_int* jpvt, double* tau, double* work, const blas_int* lwork, blas_int* info); + + // QR decomposition with pivoting (complex matrices) + void arma_fortran(arma_cgeqp3)(const blas_int* m, const blas_int* n, blas_cxf* a, const blas_int* lda, blas_int* jpvt, blas_cxf* tau, blas_cxf* work, const blas_int* lwork, float* rwork, blas_int* info); + void arma_fortran(arma_zgeqp3)(const blas_int* m, const blas_int* n, blas_cxd* a, const blas_int* lda, blas_int* jpvt, blas_cxd* tau, blas_cxd* work, const blas_int* lwork, double* rwork, blas_int* info); + // Q matrix calculation from QR decomposition (real matrices) void arma_fortran(arma_sorgqr)(const blas_int* m, const blas_int* n, const blas_int* k, float* a, const blas_int* lda, const float* tau, float* work, const blas_int* lwork, blas_int* info); void arma_fortran(arma_dorgqr)(const blas_int* m, const blas_int* n, const blas_int* k, double* a, const blas_int* lda, const double* tau, double* work, const blas_int* lwork, blas_int* info); @@ -908,6 +926,14 @@ void arma_fortran(arma_cgeqrf)(const blas_int* m, const blas_int* n, blas_cxf* a, const blas_int* lda, blas_cxf* tau, blas_cxf* work, const blas_int* lwork, blas_int* info); void arma_fortran(arma_zgeqrf)(const blas_int* m, const blas_int* n, blas_cxd* a, const blas_int* lda, blas_cxd* tau, blas_cxd* work, const blas_int* lwork, blas_int* info); + // QR decomposition with pivoting (real matrices) + void arma_fortran(arma_sgeqp3)(const blas_int* m, const blas_int* n, float* a, const blas_int* lda, blas_int* jpvt, float* tau, float* work, const blas_int* lwork, blas_int* info); + void arma_fortran(arma_dgeqp3)(const blas_int* m, const blas_int* n, double* a, const blas_int* lda, blas_int* jpvt, double* tau, double* work, const blas_int* lwork, blas_int* info); + + // QR decomposition with pivoting (complex matrices) + void arma_fortran(arma_cgeqp3)(const blas_int* m, const blas_int* n, blas_cxf* a, const blas_int* lda, blas_int* jpvt, blas_cxf* tau, blas_cxf* work, const blas_int* lwork, float* rwork, blas_int* info); + void arma_fortran(arma_zgeqp3)(const blas_int* m, const blas_int* n, blas_cxd* a, const blas_int* lda, blas_int* jpvt, blas_cxd* tau, blas_cxd* work, const blas_int* lwork, double* rwork, blas_int* info); + // Q matrix calculation from QR decomposition (real matrices) void arma_fortran(arma_sorgqr)(const blas_int* m, const blas_int* n, const blas_int* k, float* a, const blas_int* lda, const float* tau, float* work, const blas_int* lwork, blas_int* info); void arma_fortran(arma_dorgqr)(const blas_int* m, const blas_int* n, const blas_int* k, double* a, const blas_int* lda, const double* tau, double* work, const blas_int* lwork, blas_int* info); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/fn_qr.hpp new/armadillo-9.880.1/include/armadillo_bits/fn_qr.hpp --- old/armadillo-9.870.2/include/armadillo_bits/fn_qr.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/fn_qr.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -81,4 +81,63 @@ +//! QR decomposition with pivoting +template<typename T1> +inline +typename enable_if2< is_supported_blas_type<typename T1::elem_type>::value, bool >::result +qr + ( + Mat<typename T1::elem_type>& Q, + Mat<typename T1::elem_type>& R, + Mat<uword>& P, + const Base<typename T1::elem_type,T1>& X, + const char* P_mode = "matrix" + ) + { + arma_extra_debug_sigprint(); + + arma_debug_check( (&Q == &R), "qr(): Q and R are the same object"); + + const char sig = (P_mode != NULL) ? P_mode[0] : char(0); + + arma_debug_check( ((sig != 'm') && (sig != 'v')), "qr(): argument 'P_mode' must be \"vector\" or \"matrix\"" ); + + bool status = false; + + if(sig == 'v') + { + status = auxlib::qr_pivot(Q, R, P, X); + } + else + if(sig == 'm') + { + Mat<uword> P_vec; + + status = auxlib::qr_pivot(Q, R, P_vec, X); + + if(status) + { + // construct P + + const uword N = P_vec.n_rows; + + P.zeros(N,N); + + for(uword row=0; row < N; ++row) { P.at(P_vec[row], row) = uword(1); } + } + } + + if(status == false) + { + Q.soft_reset(); + R.soft_reset(); + P.soft_reset(); + arma_debug_warn("qr(): decomposition failed"); + } + + return status; + } + + + //! @} diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/include/armadillo_bits/translate_lapack.hpp new/armadillo-9.880.1/include/armadillo_bits/translate_lapack.hpp --- old/armadillo-9.870.2/include/armadillo_bits/translate_lapack.hpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/include/armadillo_bits/translate_lapack.hpp 2016-06-16 18:21:01.000000000 +0200 @@ -411,6 +411,32 @@ template<typename eT> inline void + geqp3(blas_int* m, blas_int* n, eT* a, blas_int* lda, blas_int* jpvt, eT* tau, eT* work, blas_int* lwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type<eT>::value == false )); + + if( is_float<eT>::value) { typedef float T; arma_fortran(arma_sgeqp3)(m, n, (T*)a, lda, jpvt, (T*)tau, (T*)work, lwork, info); } + else if(is_double<eT>::value) { typedef double T; arma_fortran(arma_dgeqp3)(m, n, (T*)a, lda, jpvt, (T*)tau, (T*)work, lwork, info); } + } + + + + template<typename eT> + inline + void + cx_geqp3(blas_int* m, blas_int* n, eT* a, blas_int* lda, blas_int* jpvt, eT* tau, eT* work, blas_int* lwork, typename eT::value_type* rwork, blas_int* info) + { + arma_type_check(( is_supported_blas_type<eT>::value == false )); + + if( is_cx_float<eT>::value) { typedef float T; typedef blas_cxf cx_T; arma_fortran(arma_cgeqp3)(m, n, (cx_T*)a, lda, jpvt, (cx_T*)tau, (cx_T*)work, lwork, (T*)rwork, info); } + else if(is_cx_double<eT>::value) { typedef double T; typedef blas_cxd cx_T; arma_fortran(arma_zgeqp3)(m, n, (cx_T*)a, lda, jpvt, (cx_T*)tau, (cx_T*)work, lwork, (T*)rwork, info); } + } + + + + template<typename eT> + inline + void orgqr(blas_int* m, blas_int* n, blas_int* k, eT* a, blas_int* lda, eT* tau, eT* work, blas_int* lwork, blas_int* info) { arma_type_check(( is_supported_blas_type<eT>::value == false )); @@ -418,8 +444,8 @@ if( is_float<eT>::value) { typedef float T; arma_fortran(arma_sorgqr)(m, n, k, (T*)a, lda, (T*)tau, (T*)work, lwork, info); } else if(is_double<eT>::value) { typedef double T; arma_fortran(arma_dorgqr)(m, n, k, (T*)a, lda, (T*)tau, (T*)work, lwork, info); } } - - + + template<typename eT> inline diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/smoke_test/CMakeLists.txt new/armadillo-9.880.1/smoke_test/CMakeLists.txt --- old/armadillo-9.870.2/smoke_test/CMakeLists.txt 1970-01-01 01:00:00.000000000 +0100 +++ new/armadillo-9.880.1/smoke_test/CMakeLists.txt 2016-06-16 18:21:01.000000000 +0200 @@ -0,0 +1,5 @@ +add_executable(smoke_test smoke_test.cpp) +target_link_libraries(smoke_test PRIVATE armadillo) +enable_testing() + +add_test(NAME smoke_test COMMAND smoke_test) diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/smoke_test/smoke_test.cpp new/armadillo-9.880.1/smoke_test/smoke_test.cpp --- old/armadillo-9.870.2/smoke_test/smoke_test.cpp 1970-01-01 01:00:00.000000000 +0100 +++ new/armadillo-9.880.1/smoke_test/smoke_test.cpp 2016-06-16 18:21:01.000000000 +0200 @@ -0,0 +1,27 @@ +#include <iostream> +#include <armadillo> + +using namespace arma; + +int +main() + { + std::cout << "*** smoke test start" << std::endl; + + uword N = 5; + + mat A = reshape(regspace(1, N*N), N, N); + + A.diag() += randu<vec>(N); + + mat B; + + bool status = expmat(B,A); + + A.print("A:"); + B.print("B:"); + + std::cout << ((status) ? "*** smoke test okay" : "*** smoke test failed") << std::endl; + + return (status) ? 0 : -1; + } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/src/wrapper1.cpp new/armadillo-9.880.1/src/wrapper1.cpp --- old/armadillo-9.870.2/src/wrapper1.cpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/src/wrapper1.cpp 2016-06-16 18:21:01.000000000 +0200 @@ -517,6 +517,29 @@ + void arma_fortran_with_prefix(arma_sgeqp3)(const blas_int* m, const blas_int* n, float* a, const blas_int* lda, blas_int* jpvt, float* tau, float* work, const blas_int* lwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_sgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, info); + } + + void arma_fortran_with_prefix(arma_dgeqp3)(const blas_int* m, const blas_int* n, double* a, const blas_int* lda, blas_int* jpvt, double* tau, double* work, const blas_int* lwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_dgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, info); + } + + + void arma_fortran_with_prefix(arma_cgeqp3)(const blas_int* m, const blas_int* n, blas_cxf* a, const blas_int* lda, blas_int* jpvt, blas_cxf* tau, blas_cxf* work, const blas_int* lwork, float* rwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_cgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, rwork, info); + } + + void arma_fortran_with_prefix(arma_zgeqp3)(const blas_int* m, const blas_int* n, blas_cxd* a, const blas_int* lda, blas_int* jpvt, blas_cxd* tau, blas_cxd* work, const blas_int* lwork, double* rwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_zgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, rwork, info); + } + + + void arma_fortran_with_prefix(arma_sorgqr)(const blas_int* m, const blas_int* n, const blas_int* k, float* a, const blas_int* lda, const float* tau, float* work, const blas_int* lwork, blas_int* info) { arma_fortran_sans_prefix(arma_sorgqr)(m, n, k, a, lda, tau, work, lwork, info); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/armadillo-9.870.2/src/wrapper2.cpp new/armadillo-9.880.1/src/wrapper2.cpp --- old/armadillo-9.870.2/src/wrapper2.cpp 2016-06-16 18:20:52.000000000 +0200 +++ new/armadillo-9.880.1/src/wrapper2.cpp 2016-06-16 18:21:01.000000000 +0200 @@ -465,6 +465,29 @@ + void arma_fortran_with_prefix(arma_sgeqp3)(const blas_int* m, const blas_int* n, float* a, const blas_int* lda, blas_int* jpvt, float* tau, float* work, const blas_int* lwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_sgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, info); + } + + void arma_fortran_with_prefix(arma_dgeqp3)(const blas_int* m, const blas_int* n, double* a, const blas_int* lda, blas_int* jpvt, double* tau, double* work, const blas_int* lwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_dgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, info); + } + + + void arma_fortran_with_prefix(arma_cgeqp3)(const blas_int* m, const blas_int* n, blas_cxf* a, const blas_int* lda, blas_int* jpvt, blas_cxf* tau, blas_cxf* work, const blas_int* lwork, float* rwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_cgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, rwork, info); + } + + void arma_fortran_with_prefix(arma_zgeqp3)(const blas_int* m, const blas_int* n, blas_cxd* a, const blas_int* lda, blas_int* jpvt, blas_cxd* tau, blas_cxd* work, const blas_int* lwork, double* rwork, blas_int* info) + { + arma_fortran_sans_prefix(arma_zgeqp3)(m, n, a, lda, jpvt, tau, work, lwork, rwork, info); + } + + + void arma_fortran_with_prefix(arma_sorgqr)(const blas_int* m, const blas_int* n, const blas_int* k, float* a, const blas_int* lda, const float* tau, float* work, const blas_int* lwork, blas_int* info) { arma_fortran_sans_prefix(arma_sorgqr)(m, n, k, a, lda, tau, work, lwork, info);
