is a C++ linear algebra library (matrix maths) aiming towards a good balance between speed and ease of use.
| auxlib_bones.hpp (armadillo-10.8.2.tar.xz) | : | auxlib_bones.hpp (armadillo-11.0.0.tar.xz) |
|---|
| | |
| skipping to change at line 21 | | skipping to change at line 21 |
|---|
| // Unless required by applicable law or agreed to in writing, software | | // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, | | // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and | | // See the License for the specific language governing permissions and |
| // limitations under the License. | | // limitations under the License. |
| // ------------------------------------------------------------------------ | | // ------------------------------------------------------------------------ |
| | |
| //! \addtogroup auxlib | | //! \addtogroup auxlib |
| //! @{ | | //! @{ |
| | |
|
| //! interface functions for accessing decompositions in LAPACK and ATLAS | | //! low-level interface functions for accessing LAPACK |
| class auxlib | | class auxlib |
| { | | { |
| public: | | public: |
| | |
| // | | // |
| // inv | | // inv |
| | |
| template<typename eT> | | template<typename eT> |
| inline static bool inv(Mat<eT>& A); | | inline static bool inv(Mat<eT>& A); |
| | |
| template<typename eT> | | template<typename eT> |
| inline static bool inv(Mat<eT>& out, const Mat<eT>& X); | | inline static bool inv(Mat<eT>& out, const Mat<eT>& X); |
| | |
| template<typename eT> | | template<typename eT> |
|
| | inline static bool inv_rcond(Mat<eT>& A, typename get_pod_type<eT>::result& ou |
| | t_rcond); |
| | |
| | template<typename eT> |
| inline static bool inv_tr(Mat<eT>& A, const uword layout); | | inline static bool inv_tr(Mat<eT>& A, const uword layout); |
| | |
| template<typename eT> | | template<typename eT> |
|
| inline static bool inv_sympd(Mat<eT>& A); | | inline static bool inv_tr_rcond(Mat<eT>& A, typename get_pod_type<eT>::result& |
| | out_rcond, const uword layout); |
| | |
| | template<typename eT> |
| | inline static bool inv_sympd(Mat<eT>& A, bool& out_sympd_state); |
| | |
| template<typename eT> | | template<typename eT> |
| inline static bool inv_sympd(Mat<eT>& out, const Mat<eT>& X); | | inline static bool inv_sympd(Mat<eT>& out, const Mat<eT>& X); |
| | |
| template<typename eT> | | template<typename eT> |
|
| inline static bool inv_sympd_rcond(Mat<eT>& A, const eT rcond_threshold); | | inline static bool inv_sympd_rcond(Mat<eT>& A, bool& out_sympd_state, eT& out_
rcond, const eT rcond_threshold); |
| | |
| template<typename T> | | template<typename T> |
|
| inline static bool inv_sympd_rcond(Mat< std::complex<T> >& A, const T rcond_th
reshold); | | inline static bool inv_sympd_rcond(Mat< std::complex<T> >& A, bool& out_sympd_
state, T& out_rcond, const T rcond_threshold); |
| | |
| // | | // |
| // det and log_det | | // det and log_det |
| | |
| template<typename eT> | | template<typename eT> |
| inline static bool det(eT& out_val, Mat<eT>& A); | | inline static bool det(eT& out_val, Mat<eT>& A); |
| | |
| template<typename eT> | | template<typename eT> |
| inline static bool log_det(eT& out_val, typename get_pod_type<eT>::result& out
_sign, Mat<eT>& A); | | inline static bool log_det(eT& out_val, typename get_pod_type<eT>::result& out
_sign, Mat<eT>& A); |
| | |
| | |
| skipping to change at line 234 | | skipping to change at line 240 |
|---|
| template<typename eT> | | template<typename eT> |
| inline static bool svd_dc_econ(Mat<eT>& U, Col<eT>& S, Mat<eT>& V, Mat<eT>& A)
; | | inline static bool svd_dc_econ(Mat<eT>& U, Col<eT>& S, Mat<eT>& V, Mat<eT>& A)
; |
| | |
| template<typename T> | | template<typename T> |
| inline static bool svd_dc_econ(Mat< std::complex<T> >& U, Col<T>& S, Mat< std:
:complex<T> >& V, Mat< std::complex<T> >& A); | | inline static bool svd_dc_econ(Mat< std::complex<T> >& U, Col<T>& S, Mat< std:
:complex<T> >& V, Mat< std::complex<T> >& A); |
| | |
| // | | // |
| // solve | | // solve |
| | |
| template<typename T1> | | template<typename T1> |
|
| arma_cold inline static bool solve_square_tiny(Mat<typename T1::elem_type>& ou | | |
| t, const Mat<typename T1::elem_type>& A, const Base<typename T1::elem_type,T1>& | | |
| B_expr); | | |
| | |
| template<typename T1> | | |
| inline static bool solve_square_fast(Mat<typename T1::elem_type>& out, Mat<typ
ename T1::elem_type>& A, const Base<typename T1::elem_type,T1>& B_expr); | | inline static bool solve_square_fast(Mat<typename T1::elem_type>& out, Mat<typ
ename T1::elem_type>& A, const Base<typename T1::elem_type,T1>& B_expr); |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_square_rcond(Mat<typename T1::elem_type>& out, typena
me T1::pod_type& out_rcond, Mat<typename T1::elem_type>& A, const Base<typename
T1::elem_type,T1>& B_expr, const bool allow_ugly); | | inline static bool solve_square_rcond(Mat<typename T1::elem_type>& out, typena
me T1::pod_type& out_rcond, Mat<typename T1::elem_type>& A, const Base<typename
T1::elem_type,T1>& B_expr, const bool allow_ugly); |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_square_refine(Mat<typename T1::pod_type>& out, typena
me T1::pod_type& out_rcond, Mat<typename T1::pod_type>& A, const Base<typename T
1::pod_type,T1>& B_expr, const bool equilibrate, const bool allow_ugly); | | inline static bool solve_square_refine(Mat<typename T1::pod_type>& out, typena
me T1::pod_type& out_rcond, Mat<typename T1::pod_type>& A, const Base<typename T
1::pod_type,T1>& B_expr, const bool equilibrate, const bool allow_ugly); |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_square_refine(Mat< std::complex<typename T1::pod_type
> >& out, typename T1::pod_type& out_rcond, Mat< std::complex<typename T1::pod_t
ype> >& A, const Base<std::complex<typename T1::pod_type>,T1>& B_expr, const boo
l equilibrate, const bool allow_ugly); | | inline static bool solve_square_refine(Mat< std::complex<typename T1::pod_type
> >& out, typename T1::pod_type& out_rcond, Mat< std::complex<typename T1::pod_t
ype> >& A, const Base<std::complex<typename T1::pod_type>,T1>& B_expr, const boo
l equilibrate, const bool allow_ugly); |
| | |
| // | | // |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_sympd_fast(Mat<typename T1::elem_type>& out, Mat<type
name T1::elem_type>& A, const Base<typename T1::elem_type,T1>& B_expr); | | inline static bool solve_sympd_fast(Mat<typename T1::elem_type>& out, Mat<type
name T1::elem_type>& A, const Base<typename T1::elem_type,T1>& B_expr); |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_sympd_fast_common(Mat<typename T1::elem_type>& out, M
at<typename T1::elem_type>& A, const Base<typename T1::elem_type,T1>& B_expr); | | inline static bool solve_sympd_fast_common(Mat<typename T1::elem_type>& out, M
at<typename T1::elem_type>& A, const Base<typename T1::elem_type,T1>& B_expr); |
| | |
| template<typename T1> | | template<typename T1> |
|
| inline static bool solve_sympd_rcond(Mat<typename T1::pod_type>& out, typename
T1::pod_type& out_rcond, Mat<typename T1::pod_type>& A, const Base<typename T1:
:pod_type,T1>& B_expr, const bool allow_ugly); | | inline static bool solve_sympd_rcond(Mat<typename T1::pod_type>& out, bool& ou
t_sympd_state, typename T1::pod_type& out_rcond, Mat<typename T1::pod_type>& A,
const Base<typename T1::pod_type,T1>& B_expr, const bool allow_ugly); |
| | |
| template<typename T1> | | template<typename T1> |
|
| inline static bool solve_sympd_rcond(Mat< std::complex<typename T1::pod_type>
>& out, typename T1::pod_type& out_rcond, Mat< std::complex<typename T1::pod_typ
e> >& A, const Base< std::complex<typename T1::pod_type>,T1>& B_expr, const bool
allow_ugly); | | inline static bool solve_sympd_rcond(Mat< std::complex<typename T1::pod_type>
>& out, bool& out_sympd_state, typename T1::pod_type& out_rcond, Mat< std::compl
ex<typename T1::pod_type> >& A, const Base< std::complex<typename T1::pod_type>,
T1>& B_expr, const bool allow_ugly); |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_sympd_refine(Mat<typename T1::pod_type>& out, typenam
e T1::pod_type& out_rcond, Mat<typename T1::pod_type>& A, const Base<typename T1
::pod_type,T1>& B_expr, const bool equilibrate, const bool allow_ugly); | | inline static bool solve_sympd_refine(Mat<typename T1::pod_type>& out, typenam
e T1::pod_type& out_rcond, Mat<typename T1::pod_type>& A, const Base<typename T1
::pod_type,T1>& B_expr, const bool equilibrate, const bool allow_ugly); |
| | |
| template<typename T1> | | template<typename T1> |
| inline static bool solve_sympd_refine(Mat< std::complex<typename T1::pod_type>
>& out, typename T1::pod_type& out_rcond, Mat< std::complex<typename T1::pod_ty
pe> >& A, const Base<std::complex<typename T1::pod_type>,T1>& B_expr, const bool
equilibrate, const bool allow_ugly); | | inline static bool solve_sympd_refine(Mat< std::complex<typename T1::pod_type>
>& out, typename T1::pod_type& out_rcond, Mat< std::complex<typename T1::pod_ty
pe> >& A, const Base<std::complex<typename T1::pod_type>,T1>& B_expr, const bool
equilibrate, const bool allow_ugly); |
| | |
| // | | // |
| | |
| template<typename T1> | | template<typename T1> |
| | | |
| End of changes. 8 change blocks. |
|---|
| 11 lines changed or deleted | | 14 lines changed or added |
|---|
"Fossies" - the Fresh Open Source Software Archive 