inline
bool
schur
(
Mat<typename T1::elem_type>& U,
Mat<typename T1::elem_type>& S,
const Base<typename T1::elem_type,T1>& X,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( void_ptr(&U) == void_ptr(&S), "schur(): 'U' is an alias of 'S'" );
const bool status = auxlib::schur(U, S, X.get_ref(), true);
if(status == false)
{
U.reset();
S.reset();
arma_debug_warn("schur(): decomposition failed");
}
return status;
}
inline
typename enable_if2< is_supported_blas_type<typename T1::pod_type>::value, bool >::result
eig_pair
(
Col< std::complex<typename T1::pod_type> >& eigvals,
Mat< std::complex<typename T1::pod_type> >& eigvecs,
const Base< typename T1::elem_type, T1 >& A_expr,
const Base< typename T1::elem_type, T2 >& B_expr
)
{
arma_extra_debug_sigprint();
arma_debug_check( (void_ptr(&eigvals) == void_ptr(&eigvecs)), "eig_pair(): parameter 'eigval' is an alias of parameter 'eigvec'" );
const bool status = auxlib::eig_pair(eigvals, eigvecs, true, A_expr.get_ref(), B_expr.get_ref());
if(status == false)
{
eigvals.reset();
eigvecs.reset();
arma_debug_warn("eig_pair(): decomposition failed");
}
return status;
}
inline
unwrap_check_mixed(const Col<eT1>& A, const Mat<eT2>& B)
: M_local( (void_ptr(&A) == void_ptr(&B)) ? new Col<eT1>(A) : 0 )
, M ( (void_ptr(&A) == void_ptr(&B)) ? (*M_local) : A )
{
arma_extra_debug_sigprint();
}
inline
bool
eigs_sym
(
Col<typename T1::pod_type >& eigval,
Mat<typename T1::elem_type>& eigvec,
const SpBase<typename T1::elem_type,T1>& X,
const uword n_eigvals,
const char* form = "lm",
const typename T1::elem_type tol = 0.0,
const typename arma_real_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( void_ptr(&eigval) == void_ptr(&eigvec), "eigs_sym(): paramater 'eigval' is an alias of parameter 'eigvec'" );
const bool status = sp_auxlib::eigs_sym(eigval, eigvec, X, n_eigvals, form, tol);
if(status == false)
{
eigval.reset();
arma_debug_warn("eigs_sym(): decomposition failed");
}
return status;
}
inline
bool
eig_sym
(
Col<typename T1::pod_type>& eigval,
Mat<typename T1::elem_type>& eigvec,
const Base<typename T1::elem_type,T1>& X,
const char* method = "dc",
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( void_ptr(&eigval) == void_ptr(&eigvec), "eig_sym(): eigval is an alias of eigvec" );
const char sig = (method != NULL) ? method[0] : char(0);
arma_debug_check( ((sig != 's') && (sig != 'd')), "eig_sym(): unknown method specified" );
const bool status = (sig == 'd') ? auxlib::eig_sym_dc(eigval, eigvec, X) : auxlib::eig_sym(eigval, eigvec, X);
if(status == false)
{
eigval.reset();
eigvec.reset();
arma_bad("eig_sym(): failed to converge", false);
}
return status;
}
inline
bool
eig_sym
(
Col<typename T1::pod_type>& eigval,
Mat<typename T1::elem_type>& eigvec,
const Base<typename T1::elem_type,T1>& X,
const char* method = "dc",
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
typedef typename T1::elem_type eT;
const char sig = (method != NULL) ? method[0] : char(0);
arma_debug_check( ((sig != 's') && (sig != 'd')), "eig_sym(): unknown method specified" );
arma_debug_check( void_ptr(&eigval) == void_ptr(&eigvec), "eig_sym(): parameter 'eigval' is an alias of parameter 'eigvec'" );
const Proxy<T1> P(X.get_ref());
const bool is_alias = P.is_alias(eigvec);
Mat<eT> eigvec_tmp;
Mat<eT>& eigvec_out = (is_alias == false) ? eigvec : eigvec_tmp;
bool status = false;
if(sig == 'd') { status = auxlib::eig_sym_dc(eigval, eigvec_out, P.Q); }
if(status == false) { status = auxlib::eig_sym(eigval, eigvec_out, P.Q); }
if(status == false)
{
eigval.reset();
eigvec.reset();
arma_debug_warn("eig_sym(): decomposition failed");
}
else
{
if(is_alias) { eigvec.steal_mem(eigvec_tmp); }
}
return status;
}
bool boost_shared_ptr_void()
{
boost::shared_ptr< boost::remove_pointer<void*>::type > void_ptr( malloc(128), my_free );
if (NULL == void_ptr.get()) return false;
log_msg "void pointer allocated at 0x%p", void_ptr.get() log_end
return true;
}
inline
bool
hess
(
Mat<typename T1::elem_type>& U,
Mat<typename T1::elem_type>& H,
const Base<typename T1::elem_type,T1>& X,
const typename arma_blas_type_only<typename T1::elem_type>::result* junk = 0
)
{
arma_extra_debug_sigprint();
arma_ignore(junk);
arma_debug_check( void_ptr(&U) == void_ptr(&H), "hess(): 'U' is an alias of 'H'" );
typedef typename T1::elem_type eT;
Col<eT> tao;
const bool status = auxlib::hess(H, X.get_ref(), tao);
if(H.n_rows == 0)
{
U.reset();
}
else
if(H.n_rows == 1)
{
U.ones(1, 1);
}
else
if(H.n_rows == 2)
{
U.eye(2, 2);
}
else
{
U.eye(size(H));
Col<eT> v;
for(uword i=0; i < H.n_rows-2; ++i)
{
// TODO: generate v in a more efficient manner;
// TODO: the .ones() operation is an overkill, as most of v is overwritten afterwards
v.ones(H.n_rows-i-1);
v(span(1, H.n_rows-i-2)) = H(span(i+2, H.n_rows-1), i);
U(span::all, span(i+1, H.n_rows-1)) -= tao(i) * (U(span::all, span(i+1, H.n_rows-1)) * v * v.t());
}
U(span::all, H.n_rows-1) = U(span::all, H.n_rows-1) * (eT(1) - tao(H.n_rows-2));
for(uword i=0; i < H.n_rows-2; ++i)
{
H(span(i+2, H.n_rows-1), i).zeros();
}
}
if(status == false)
{
U.soft_reset();
H.soft_reset();
arma_debug_warn("hess(): decomposition failed");
}
return status;
}
inline
hid_t
load_and_convert_hdf5
(
eT *dest,
hid_t dataset,
hid_t datatype,
uword n_elem
)
{
// We can't use nice template specializations here
// as the determination of the type of 'datatype' must be done at runtime.
// So we end up with this ugliness...
hid_t search_type;
bool is_equal;
// u8
search_type = get_hdf5_type<u8>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<u8> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// s8
search_type = get_hdf5_type<s8>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<s8> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// u16
search_type = get_hdf5_type<u16>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<u16> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// s16
search_type = get_hdf5_type<s16>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<s16> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// u32
search_type = get_hdf5_type<u32>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<u32> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// s32
search_type = get_hdf5_type<s32>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<s32> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
#if defined(ARMA_USE_U64S64)
{
// u64
search_type = get_hdf5_type<u64>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<u64> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// s64
search_type = get_hdf5_type<s64>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<s64> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
}
#endif
#if defined(ARMA_ALLOW_LONG)
{
// ulng_t
search_type = get_hdf5_type<ulng_t>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<ulng_t> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// slng_t
search_type = get_hdf5_type<slng_t>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<slng_t> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
}
#endif
// float
search_type = get_hdf5_type<float>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<float> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// double
search_type = get_hdf5_type<double>();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
Col<double> v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert(dest, v.memptr(), n_elem);
return status;
}
// complex float
search_type = get_hdf5_type< std::complex<float> >();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
if(is_cx<eT>::no)
{
return -1; // can't read complex data into non-complex matrix/cube
}
Col< std::complex<float> > v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert_cx(dest, v.memptr(), n_elem);
return status;
}
// complex double
search_type = get_hdf5_type< std::complex<double> >();
is_equal = (arma_H5Tequal(datatype, search_type) > 0);
arma_H5Tclose(search_type);
if(is_equal)
{
if(is_cx<eT>::no)
{
return -1; // can't read complex data into non-complex matrix/cube
}
Col< std::complex<double> > v(n_elem);
hid_t status = arma_H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(v.memptr()));
arrayops::convert_cx(dest, v.memptr(), n_elem);
return status;
}
return -1; // Failure.
}
//! Search an HDF5 file for the given dataset names.
//! If 'exact' is true, failure to find a dataset in the list of names means that -1 is returned.
//! If 'exact' is false and no datasets are found, -1 is returned.
//! The number of dimensions is used to help prune down invalid datasets;
//! 2 dimensions is a matrix, 1 dimension is a vector, and 3 dimensions is a cube.
//! If the number of dimensions in a dataset is less than or equal to num_dims,
//! it will be considered -- for instance, a one-dimensional HDF5 vector can be loaded as a single-column matrix.
inline
hid_t
search_hdf5_file
(
const std::vector<std::string>& names,
hid_t hdf5_file,
int num_dims = 2,
bool exact = false
)
{
hdf5_search_info search_info = { names, num_dims, exact, -1, names.size() };
// We'll use the H5Ovisit to track potential entries.
herr_t status = arma_H5Ovisit(hdf5_file, H5_INDEX_NAME, H5_ITER_NATIVE, hdf5_search_callback, void_ptr(&search_info));
// Return the best match; it will be -1 if there was a problem.
return (status < 0) ? -1 : search_info.best_match;
}
arma_inline bool is_alias(const Mat<eT2>& X) const { return (void_ptr(&(Q.m)) == void_ptr(&X)); }
inline
hid_t
load_and_convert_hdf5
(
Mat<eT>& dest,
hid_t dataset,
hid_t datatype,
hsize_t* dims
)
{
const uword n_rows = dims[0];
const uword n_cols = dims[1];
// We can't use nice template specializations here
// as the determination of the type of 'datatype' must be done at runtime.
// So we end up with this ugliness...
hid_t search_type;
bool is_equal;
// u8
search_type = get_hdf5_type<u8>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<u8> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// s8
search_type = get_hdf5_type<s8>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<s8> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// u16
search_type = get_hdf5_type<u16>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<u16> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// s16
search_type = get_hdf5_type<s16>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<s16> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// u32
search_type = get_hdf5_type<u32>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<u32> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// s32
search_type = get_hdf5_type<s32>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<s32> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
#if defined(ARMA_64BIT_WORD)
{
// u64
search_type = get_hdf5_type<u64>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<u64> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// s64
search_type = get_hdf5_type<s64>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<s64> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
}
#endif
// float
search_type = get_hdf5_type<float>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<float> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// double
search_type = get_hdf5_type<double>();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat<double> m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// complex float
search_type = get_hdf5_type< std::complex<float> >();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat< std::complex<float> > m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
return status;
}
// complex double
search_type = get_hdf5_type< std::complex<double> >();
is_equal = (H5Tequal(datatype, search_type) > 0);
H5Tclose(search_type);
if(is_equal)
{
Mat< std::complex<double> > m(n_rows, n_cols);
hid_t status = H5Dread(dataset, datatype, H5S_ALL, H5S_ALL, H5P_DEFAULT, void_ptr(m.memptr()));
dest = conv_to< Mat<eT> >::from(m); // Convert.
H5Tclose(search_type);
return status;
}
return -1; // Failure.
}
arma_inline bool is_alias(const Cube<eT2>& X) const { return (void_ptr(&Q) == void_ptr(&X)); }
