Array handler between a distributed array (left), typically one held on disk, and a contiguous array (right), e.g. std::vector or Span.
More...
template<class AL, class AR>
class molpro::linalg::array::ArrayHandlerDDiskIterable< AL, AR >
Array handler between a distributed array (left), typically one held on disk, and a contiguous array (right), e.g. std::vector or Span.
This is ArrayHandlerIterableDDisk the other way round, see there for how the arrays are accessed.
A new distributed array made as a copy of a contiguous one is created by a copy function. By default, this is AL::CreateTempCopy() on molpro::mpi::comm_self(), because the contiguous array is not distributed, optionally with a directory for the file.
|
| | ArrayHandlerDDiskIterable () |
| | New arrays are created by AL::CreateTempCopy() on molpro::mpi::comm_self(), with any file in its default location.
|
| |
| | ArrayHandlerDDiskIterable (const std::string &directory) |
| | New arrays are created by AL::CreateTempCopy() on molpro::mpi::comm_self(), with any file in directory.
|
| |
| | ArrayHandlerDDiskIterable (std::function< AL(const AR &)> copy_func) |
| | Constructor taking a copy function, which returns a new distributed array as a copy of a contiguous one.
|
| |
| ProxyHandle | lazy_handle () override |
| | Returns a lazy handle. Most implementations simply need to call the overload: return lazy_handle(*this);.
|
| |
| void | copy (AL &x, const AR &y) override |
| | Copy content of y into x.
|
| |
| void | scal (value_type alpha, AL &x) override |
| |
| void | fill (value_type alpha, AL &x) override |
| |
| void | axpy (value_type alpha, const AR &x, AL &y) override |
| |
| value_type | dot (const AL &x, const AR &y) override |
| | The hermitian inner product <x|y>: conjugate-linear in x, linear in y.
|
| |
| void | gemm_outer (const Matrix< value_type > alphas, const CVecRef< AR > &xx, const VecRef< AL > &yy) override |
| |
| Matrix< value_type > | gemm_inner (const CVecRef< AL > &xx, const CVecRef< AR > &yy) override |
| |
| std::map< size_t, value_type_abs > | select_max_dot (size_t n, const AL &x, const AR &y) override |
| | Select n indices with largest by absolute value contributions to the dot product.
|
| |
| std::map< size_t, value_type > | select (size_t n, const AL &x, bool max=false, bool ignore_sign=false) override |
| | Select n indices with largest (or smallest) actual (or absolute) value.
|
| |
Public Member Functions inherited from molpro::linalg::array::ArrayHandlerWithCopyFunc< AL, AR > |
| | ArrayHandlerWithCopyFunc (copy_func_type copy_func) |
| | Constructor taking a copy function.
|
| |
| AL | copy (const AR &source) override |
| |
Public Member Functions inherited from molpro::linalg::array::ArrayHandler< AL, AR > |
| const Counter & | counter () const |
| |
| std::string | counter_to_string (std::string L, std::string R) |
| |
| void | clear_counter () |
| |
| virtual | ~ArrayHandler () |
| | Destroys ArrayHandler instance and invalidates any LazyHandler it created. Invalidated handler will not evaluate.
|
| |
|
Public Types inherited from molpro::linalg::array::ArrayHandlerWithCopyFunc< AL, AR > |
| using | copy_func_type = std::function< AL(const AR &)> |
| |
Public Types inherited from molpro::linalg::array::ArrayHandler< AL, AR > |
| using | value_type_L = typename array::mapped_or_value_type_t< AL > |
| |
| using | value_type_R = typename array::mapped_or_value_type_t< AR > |
| |
| using | value_type = decltype(value_type_L{} *value_type_R{}) |
| |
| using | value_type_abs = decltype(check_abs< value_type >()) |
| |
Protected Member Functions inherited from molpro::linalg::array::ArrayHandler< AL, AR > |
| | ArrayHandler () |
| |
| | ArrayHandler (const ArrayHandler &)=default |
| |
| virtual void | error (const std::string &message) |
| | Throws an error.
|
| |
| virtual void | fused_axpy (const std::vector< std::tuple< size_t, size_t, size_t > > ®, const std::vector< value_type > &alphas, const std::vector< std::reference_wrapper< const AR > > &xx, std::vector< std::reference_wrapper< AL > > &yy) |
| | Default implementation of fused_axpy without any simplification.
|
| |
| virtual void | fused_dot (const std::vector< std::tuple< size_t, size_t, size_t > > ®, const std::vector< std::reference_wrapper< const AL > > &xx, const std::vector< std::reference_wrapper< const AR > > &yy, std::vector< std::reference_wrapper< value_type > > &out) |
| | Default implementation of fused_dot without any simplification.
|
| |
| void | save_handle (const std::shared_ptr< LazyHandle > &handle) |
| | Save weak ptr to a lazy handle.
|
| |
| ProxyHandle | lazy_handle (ArrayHandler< AL, AR > &handler) |
| |
Protected Attributes inherited from molpro::linalg::array::ArrayHandlerWithCopyFunc< AL, AR > |
| copy_func_type | m_copy_func |
| | function for making a copy
|
| |
Protected Attributes inherited from molpro::linalg::array::ArrayHandler< AL, AR > |
| std::unique_ptr< Counter > | m_counter |
| |
| std::vector< std::weak_ptr< LazyHandle > > | m_lazy_handles |
| | keeps track of all created lazy handles
|
| |
template<class AL , class AR >
The hermitian inner product <x|y>: conjugate-linear in x, linear in y.
For a real element type this is the ordinary dot product; for a complex one the left argument is conjugated, so that dot(x, x) is real and non-negative and an overlap matrix built from it is hermitian rather than complex symmetric.
Implements molpro::linalg::array::ArrayHandler< AL, AR >.