ArrayHandlerIterableSparse.h

#ifndef LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_ARRAYHANDLERITERABLESPARSE_H
#define LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_ARRAYHANDLERITERABLESPARSE_H
#include <molpro/linalg/array/ArrayHandler.h>
#include <molpro/linalg/array/util/gemm.h>
#include <molpro/linalg/array/util/select.h>
#include <molpro/linalg/array/util/select_max_dot.h>
#include <numeric>
#include <stdexcept>
 
namespace molpro::linalg::array {
using molpro::linalg::array::util::gemm_inner_default;
using molpro::linalg::array::util::gemm_outer_default;
template <typename AL, typename AR, bool = has_mapped_type_v<AR>>
class ArrayHandlerIterableSparse : public ArrayHandler<AL, AR> {};
 
template <typename AL, typename AR>
class ArrayHandlerIterableSparse<AL, AR, true> : public ArrayHandler<AL, AR> {
public:
  using typename ArrayHandler<AL, AR>::value_type_L;
  using typename ArrayHandler<AL, AR>::value_type_R;
  using typename ArrayHandler<AL, AR>::value_type;
  using typename ArrayHandler<AL, AR>::value_type_abs;
  using typename ArrayHandler<AL, AR>::ProxyHandle;
 
  AL copy(const AR &source) override {
    AL result;
    copy(result, source);
    return result;
  };
 
  void copy(AL &x, const AR &y) override {
    // checked before x is overwritten
    if (not y.empty() and y.rbegin()->first >= x.size())
      error("ArrayHandlerIterableSparse::copy() sparse array y is incompatible");
    std::fill(x.begin(), x.end(), 0);
    for (const auto &s : y)
      *(x.begin() + s.first) = s.second;
  }
 
  void scal(value_type alpha, AL &x) override {
    throw std::logic_error("Use ArrayHandlerIterable for unary operations");
  };
 
  void fill(value_type alpha, AL &x) override {
    throw std::logic_error("Use ArrayHandlerIterable for unary operations");
  };
 
  void axpy(value_type alpha, const AR &x, AL &y) override {
    for (const auto &el_x : x)
      if (el_x.first < y.size())
        y[el_x.first] += alpha * el_x.second;
  };
 
  value_type dot(const AL &x, const AR &y) override {
    value_type tot = 0;
    for (const auto &el_y : y)
      if (el_y.first < x.size())
        tot += molpro::linalg::conjugate(static_cast<value_type>(x[el_y.first])) *
               static_cast<value_type>(el_y.second);
    return tot;
  };
 
  void gemm_outer(const Matrix<value_type> alphas, const CVecRef<AR> &xx, const VecRef<AL> &yy) override {
    gemm_outer_default(*this, alphas, xx, yy);
  }
 
  Matrix<value_type> gemm_inner(const CVecRef<AL> &xx, const CVecRef<AR> &yy) override {
    return gemm_inner_default(*this, xx, yy);
  }
 
  std::map<size_t, value_type_abs> select_max_dot(size_t n, const AL &x, const AR &y) override {
    if (n > x.size() || n > y.size())
      error("ArrayHandlerIterableSparse::select_max_dot() n is too large");
    return util::select_max_dot_iter_sparse<AL, AR, value_type, value_type_abs>(n, x, y);
  }
  std::map<size_t, value_type> select(size_t n, const AL &x, bool max = false, bool ignore_sign = false) override {
    if (n > x.size())
      error("ArrayHandlerIterableSparse::select() n is too large");
    return util::select<AL, value_type>(n, x, max, ignore_sign);
  }
 
  ProxyHandle lazy_handle() override { return this->lazy_handle(*this); };
 
protected:
  using ArrayHandler<AL, AR>::error;
  using ArrayHandler<AL, AR>::lazy_handle;
  using ArrayHandler<AL, AR>::m_lazy_handles;
};
 
} // namespace molpro::linalg::array
 
#endif // LINEARALGEBRA_SRC_MOLPRO_LINALG_ARRAY_ARRAYHANDLERITERABLESPARSE_H