util.h

#ifndef LINEARALGEBRA_SRC_MOLPRO_LINALG_ITSOLV_UTIL_H
#define LINEARALGEBRA_SRC_MOLPRO_LINALG_ITSOLV_UTIL_H
#include <molpro/Profiler.h>
#include <molpro/linalg/itsolv/ArrayHandlers.h>
#include <molpro/linalg/itsolv/subspace/Matrix.h>
#include <molpro/linalg/itsolv/wrap.h>
 
#include <locale>
#include <map>
#include <string>
 
namespace molpro::linalg::itsolv::util {
 
template <typename value_type, typename value_type_abs>
void remove_null_vectors(subspace::Matrix<value_type>& lin_trans, std::vector<value_type_abs>& norm, const size_t start,
                         const size_t end, const value_type_abs norm_thresh) {
  for (size_t i = start, j = start; i < end; ++i) {
    if (norm[j] < norm_thresh) {
      norm.erase(begin(norm) + j);
      lin_trans.remove_row(j);
    } else
      ++j;
  }
}
 
template <class ForwardIt, class EndIterator, typename Int>
bool is_iota(ForwardIt it_start, EndIterator it_end, Int value_start) {
  bool result = true;
  for (auto it = it_start; it != it_end && result; ++it, ++value_start)
    result = (*it) == value_start;
  return result;
}
 
template <class R, class Q>
Q construct_zeroed_copy(const R& param, array::ArrayHandler<Q, R>& handler) {
  auto q = handler.copy(param);
  handler.fill(0, q);
  return q;
}
 
template <class R, class Q, class P, typename value_type>
void construct_solutions(const VecRef<R>& params, const std::vector<int>& roots,
                         const subspace::Matrix<value_type>& solutions, const CVecRef<P>& pparams,
                         const CVecRef<Q>& qparams, const CVecRef<Q>& dparams, size_t oP, size_t oQ, size_t oD,
                         array::ArrayHandler<R, R>& handler_rr, array::ArrayHandler<R, P>& handler_rp,
                         array::ArrayHandler<R, Q>& handler_rq) {
  auto prof = molpro::Profiler::single();
  prof->start("itsolv::util::construct_solutions");
  assert(params.size() >= roots.size());
  for (size_t i = 0; i < roots.size(); ++i)
    handler_rr.fill(0, params.at(i));
  for (size_t i = 0; i < roots.size(); ++i) {
    auto root = roots[i];
    for (size_t j = 0; j < pparams.size(); ++j)
      handler_rp.axpy(solutions(root, oP + j), pparams.at(j), params.at(i));
    for (size_t j = 0; j < qparams.size(); ++j)
      handler_rq.axpy(solutions(root, oQ + j), qparams.at(j), params.at(i));
    for (size_t j = 0; j < dparams.size(); ++j)
      handler_rq.axpy(solutions(root, oD + j), dparams.at(j), params.at(i));
  }
  prof->stop();
}
 
template <class Container>
void delete_parameters(std::vector<int> indices, Container& params) {
  std::sort(std::begin(indices), std::end(indices), std::greater<int>());
  for (auto i : indices)
    params.erase(begin(params) + i);
}
 
class StringFacet {
public:
  std::string toupper(std::string in) const;
  std::string tolower(std::string in) const;
  bool tobool(const std::string& in) const;
  static void crop_space(std::string& path);
  static std::map<std::string, std::string> parse_keyval_string(std::string s);
 
private:
  const std::ctype<char>& facet = std::use_facet<std::ctype<char>>(std::locale());
};
 
} // namespace molpro::linalg::itsolv::util
#endif // LINEARALGEBRA_SRC_MOLPRO_LINALG_ITSOLV_UTIL_H