Implements IterativeSolver interface that is common to all solvers. More...

#include <IterativeSolverTemplate.h>

Inheritance diagram for molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >:

[legend]

Detailed Description

template<template< class, class, class > class Solver, class R, class Q, class P>
class molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >

Implements IterativeSolver interface that is common to all solvers.

Template Parameters

Solver one of the solvers that inherits from IterativeSolver.

Public Member Functions
	IterativeSolverTemplate ()=delete

	IterativeSolverTemplate (const IterativeSolverTemplate< Solver, R, Q, P > &)=delete

	IterativeSolverTemplate (IterativeSolverTemplate< Solver, R, Q, P > &&) noexcept=default

IterativeSolverTemplate< Solver, R, Q, P > &	operator= (const IterativeSolverTemplate< Solver, R, Q, P > &)=delete

IterativeSolverTemplate< Solver, R, Q, P > &	operator= (IterativeSolverTemplate< Solver, R, Q, P > &&) noexcept=default

void	set_logger (std::shared_ptr< Logger > logger) override

Logger &	logger () override

int	add_vector (const VecRef< R > &parameters, const VecRef< R > &actions) override

int	add_vector (const VecRef< R > &parameters, const VecRef< R > &actions, const VecRef< R > &metric_actions) override

bool	supports_metric (MetricKind kind) const override

void	set_metric (MetricKind kind, MetricStorage storage=MetricStorage::Stored, fapply_metric_type apply_metric={}) override

MetricKind	metric_kind () const override

void	set_check_metric (bool check) override

bool	get_check_metric () const override

MetricStorage	metric_storage () const override

int	add_vector (std::vector< R > &parameters, std::vector< R > &actions) override

int	add_vector (R &parameters, R &actions, value_type value=0) override

size_t	add_p (const CVecRef< P > &pparams, const array::Span< value_type > &pp_action_matrix, const VecRef< R > &parameters, const VecRef< R > &actions, fapply_on_p_type apply_p) override

size_t	add_p (const CVecRef< P > &pparams, const array::Span< value_type > &pp_action_matrix, const VecRef< R > &parameters, const VecRef< R > &actions, fapply_on_p_type apply_p, const PSpaceMetric &metric) override

void	clearP () override

void	solution (const std::vector< int > &roots, const VecRef< R > &parameters, const VecRef< R > &residual) override

void	solution (const std::vector< int > &roots, std::vector< R > &parameters, std::vector< R > &residual) override

void	solution (R &parameters, R &residual) override

void	solution_params (const std::vector< int > &roots, std::vector< R > &parameters) override

void	solution_params (const std::vector< int > &roots, const VecRef< R > &parameters) override

void	solution_params (R &parameters) override

std::vector< size_t >	suggest_p (const CVecRef< R > &solution, const CVecRef< R > &residual, size_t max_number, value_type_abs threshold) override

const std::vector< int > &	working_set () const override

size_t	n_roots () const override

void	set_n_roots (size_t roots) override

void	set_options (const Options &options) override

std::shared_ptr< Options >	get_options () const override

const std::vector< value_type_abs > &	errors () const override

const Statistics &	statistics () const override

void	report (std::ostream &cout, bool endl=true) const override

void	iteration_report () const

void	summary_report () const

void	report () const override

void	set_convergence_threshold (value_type_abs thresh) override

value_type_abs	convergence_threshold () const override

void	set_convergence_threshold_value (value_type_abs thresh) override

value_type_abs	convergence_threshold_value () const override

void	set_verbosity (Verbosity v) override

void	set_verbosity (int v) override

Verbosity	get_verbosity () const override

void	set_max_iter (int n) override

int	get_max_iter () const override

void	set_max_p (int n) override

int	get_max_p () const override

void	set_p_threshold (value_type_abs threshold) override

value_type_abs	get_p_threshold () const override

const subspace::Dimensions &	dimensions () const override
	Access dimensions of the subspace.

scalar_type	value () const override

void	set_profiler (molpro::profiler::Profiler &profiler) override

void	set_profiler (std::shared_ptr< molpro::profiler::Profiler > profiler) override

const std::shared_ptr< molpro::profiler::Profiler > &	profiler () const override

std::vector< scalar_type >	current_values () const
	The values reported in the iteration events: eigenvalues of eigensystems, the function value otherwise.

bool	solve (const VecRef< R > &parameters, const VecRef< R > &actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	solve (const VecRef< R > &parameters, const VecRef< R > &actions, const VecRef< R > &metric_actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	solve (R &parameters, R &actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	solve (std::vector< R > &parameters, std::vector< R > &actions, const Problem< R > &problem, bool generate_initial_guess=false) override

bool	test_problem (const Problem< R > &problem, R &v0, R &v1, int verbosity, value_type_abs threshold) const override

Protected Member Functions
virtual void	prepare_solve (const Problem< R > &problem, const VecRef< R > &actions)
	Prepares solving problem in solve(), after the problem has been checked and before the solver changes, e.g. by taking over data of the problem.

bool	solve_impl (const VecRef< R > &parameters, const VecRef< R > &actions, const VecRef< R > &metric_actions, const Problem< R > &problem, bool generate_initial_guess)
	Implements both overloads of solve(), with empty metric_actions for a problem without a metric.

void	solution_impl (const std::vector< int > &roots, const VecRef< R > &parameters, const VecRef< R > &residual, const VecRef< R > &scratch)
	Implements solution()

template<typename ConstructResidual >
void	solution_impl (const std::vector< int > &roots, const VecRef< R > &parameters, const VecRef< R > &residual, const VecRef< R > &scratch, ConstructResidual &&construct_residual_with)
	Implements solution(), with the residuals constructed by the given function in place of construct_residual(), which takes the same arguments.

void	construct_solutions (const std::vector< int > &rows, const subspace::Matrix< value_type > &solutions, const VecRef< R > &parameters)
	Constructs the subspace vectors with the coefficients in the given rows of solutions.

void	construct_actions (const std::vector< int > &rows, const subspace::Matrix< value_type > &solutions, const VecRef< R > &actions)
	Constructs the actions on the subspace vectors with the coefficients in the given rows of solutions.

	IterativeSolverTemplate (std::shared_ptr< subspace::IXSpace< R, Q, P > > xspace, std::shared_ptr< subspace::ISubspaceSolver< R, Q, P > > solver, std::shared_ptr< ArrayHandlers< R, Q, P > > handlers, std::shared_ptr< Statistics > stats, std::shared_ptr< Logger > logger)

virtual	~IterativeSolverTemplate ()

bool	test_metric (const Problem< R > &problem, R &v0, R &v1, int verbosity, value_type_abs threshold) const
	Tests that the metric of a problem is Hermitian, <u\|M v> = <M u\|v>, and, if its kind says so, positive (semi)definite, on the first two test parameters.

virtual void	combine_errors ()
	Implementation class can overload this to combine the errors of solutions, once those of all are known.

virtual void	set_value_errors ()
	Implementation class should overload this to set errors in the current values (e.g. change in eigenvalues)

virtual void	construct_residual (const std::vector< int > &roots, const CVecRef< R > &params, const VecRef< R > &actions, const detail::MetricSolutions< R, Q > &metric_solutions)=0
	Constructs residual for given roots provided their parameters and actions.

virtual void	compute_errors (const std::vector< int > &roots, const CVecRef< R > &params, const CVecRef< R > &residuals, const std::vector< value_type_abs > &solution_norms, std::vector< value_type_abs > &errors)
	Computes the errors of roots, given their parameters and residuals; by default the norms of the residuals.

virtual void	solution_with_errors (const std::vector< int > &roots, const VecRef< R > &parameters, const VecRef< R > &residual, const VecRef< R > &scratch, const std::vector< value_type_abs > &solution_norms, std::vector< value_type_abs > &errors)
	Constructs the parameters and residuals of roots, as solution_impl() does, and computes their errors, as compute_errors() does.

virtual bool	linearEigensystem () const

size_t	add_p_impl (const CVecRef< P > &pparams, const array::Span< value_type > &pp_action_matrix, const array::Span< value_type > &pp_metric_matrix, const VecRef< R > &parameters, const VecRef< R > &actions, fapply_on_p_type apply_p)
	Implements add_p(), with an empty pp_metric_matrix for a problem without a metric.

void	check_pspace_metric (MetricKind kind, const CVecRef< P > &pparams, const array::Span< value_type > &pp_metric_matrix) const
	Throws if the metric matrix in the P space is not given for a metric of this kind, or, unless checks are off, shows that the metric does not have the properties of its kind; checked before the P space is added.

void	check_metric_change (MetricKind kind, MetricStorage storage) const
	Throws if set_metric() with these arguments is not possible, apart from the function applying the metric.

void	check_metric_positive ()
	For a positive (semi)definite metric, throws if the metric matrix shows that it is not, unless checks are off.

size_t	n_added_vectors (const VecRef< R > &parameters) const
	The number of the given parameters that add_vector() takes up: no more than there are in the working set.

int	add_vector_impl (const VecRef< R > &parameters, const VecRef< R > &actions, const VecRef< R > &metric_actions)
	Implements add_vector()

size_t	solve_and_generate_working_set (const VecRef< R > &parameters, const VecRef< R > &action, const VecRef< R > &scratch={})
	Solves the subspace problems and selects the working set of roots, returning their parameters and residual in parameters and action.

template<typename TTT >
void	check_consistent_number_of_roots_and_solutions (const std::vector< TTT > &roots, const size_t nparams)

bool	end_iteration_needed () override

void	finalize () override

bool	verbosity_at_least (Verbosity v) const
	Whether output of verbosity v is printed in solve(); everything is printed if no verbosity was set.

void	generate_initial_guess_from_diagonals (const VecRef< R > &parameters, const Q &diagonals)
	Fills parameters with unit vectors at the positions of the lowest diagonal elements.

std::vector< P >	select_pspace (const Q &diagonals)
	Selects the P space from the lowest diagonal elements, subject to max_p and p_threshold.

std::pair< std::vector< value_type >, std::vector< value_type > >	pspace_problem_matrices (const std::vector< P > &pspace, const Problem< R > &problem, const bool metric, const bool store_metric_actions) const
	Adds the P space to the subspace using the P-space kernel provided by problem; returns the working-set size.

size_t	initialise_pspace (const std::vector< P > &pspace, const Problem< R > &problem, std::pair< std::vector< value_type >, std::vector< value_type > > &matrices, const VecRef< R > &parameters, const VecRef< R > &actions)
	Adds the P space to the subspace with the matrices of pspace_problem_matrices(); returns the working-set size.

Protected Attributes
std::shared_ptr< ArrayHandlers< R, Q, P > >	m_handlers
	Array handlers.

std::shared_ptr< subspace::IXSpace< R, Q, P > >	m_xspace
	manages the subspace and associated data

std::shared_ptr< subspace::ISubspaceSolver< R, Q, P > >	m_subspace_solver
	solves the subspace problem

std::vector< value_type_abs >	m_errors
	errors from the most recent solution

std::vector< value_type_abs >	m_value_errors
	value errors from the most recent solution

std::vector< int >	m_working_set
	indices of roots in the working set

size_t	m_nroots {0}
	number of roots the solver is searching for

value_type_abs	m_convergence_threshold {1.0e-8}
	residual norms less than this mark a converged solution

value_type_abs	m_convergence_threshold_value
	value changes less than this mark a converged solution

std::shared_ptr< Statistics >	m_stats
	accumulates statistics of operations performed by the solver

std::shared_ptr< Logger >	m_logger
	logger

fapply_on_p_type	m_apply_p = {}
	function that evaluates effect of action on the P space projection

std::optional< Verbosity >	m_verbosity = {}
	how much output to print in solve()

int	m_max_iter = 100
	maximum number of iterations in solve()

size_t	m_max_p = 0
	maximum size of P space

MetricKind	m_metric_kind = MetricKind::Identity
	the metric declared with set_metric()

MetricStorage	m_metric_storage = MetricStorage::Stored
	how the actions of the metric are obtained

fapply_metric_type	m_apply_metric = {}
	applies the metric on the fly, if its actions are not stored

bool	m_check_metric = true
	whether the properties of the metric are checked

detail::MetricChecker< R, Q, P >	m_metric_checker
	checks the properties of the metric

fapply_on_p_type	m_apply_metric_p = {}
	adds the action of the metric on the P space, if its actions are stored

value_type_abs	m_p_threshold = std::numeric_limits<value_type_abs>::max()
	threshold for selecting P space

bool	m_end_iteration_needed = true
	whether end_iteration should be called after any preconditioner

bool	m_solutions_outdated = false
	whether the subspace was changed since the solutions of its problem were found

Constructor & Destructor Documentation

◆ IterativeSolverTemplate() [1/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::IterativeSolverTemplate ( )

delete

◆ IterativeSolverTemplate() [2/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::IterativeSolverTemplate ( const IterativeSolverTemplate< Solver, R, Q, P > & )

delete

◆ IterativeSolverTemplate() [3/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::IterativeSolverTemplate ( IterativeSolverTemplate< Solver, R, Q, P > && )

defaultnoexcept

◆ IterativeSolverTemplate() [4/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::IterativeSolverTemplate	(	std::shared_ptr< subspace::IXSpace< R, Q, P > >	xspace,
		std::shared_ptr< subspace::ISubspaceSolver< R, Q, P > >	solver,
		std::shared_ptr< ArrayHandlers< R, Q, P > >	handlers,
		std::shared_ptr< Statistics >	stats,
		std::shared_ptr< Logger >	logger
	)

inlineprotected

◆ ~IterativeSolverTemplate()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::~IterativeSolverTemplate ( )

inlineprotectedvirtual

Member Function Documentation

◆ add_p() [1/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_p	(	const CVecRef< P > &	pparams,
		const array::Span< value_type > &	pp_action_matrix,
		const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		fapply_on_p_type	apply_p
	)

inlineoverride

◆ add_p() [2/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_p	(	const CVecRef< P > &	pparams,
		const array::Span< value_type > &	pp_action_matrix,
		const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		fapply_on_p_type	apply_p,
		const PSpaceMetric &	metric
	)

inlineoverride

◆ add_p_impl()

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_p_impl	(	const CVecRef< P > &	pparams,
		const array::Span< value_type > &	pp_action_matrix,
		const array::Span< value_type > &	pp_metric_matrix,
		const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		fapply_on_p_type	apply_p
	)

inlineprotected

Implements add_p(), with an empty pp_metric_matrix for a problem without a metric.

◆ add_vector() [1/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_vector	(	const VecRef< R > &	parameters,
		const VecRef< R > &	actions
	)

inlineoverride

◆ add_vector() [2/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_vector	(	const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		const VecRef< R > &	metric_actions
	)

inlineoverride

◆ add_vector() [3/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_vector	(	R &	parameters,
		R &	actions,
		value_type	value = `0`
	)

inlineoverride

◆ add_vector() [4/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_vector	(	std::vector< R > &	parameters,
		std::vector< R > &	actions
	)

inlineoverride

◆ add_vector_impl()

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::add_vector_impl	(	const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		const VecRef< R > &	metric_actions
	)

inlineprotected

Implements add_vector()

Parameters

metric_actions For a problem with a metric, the actions of the metric on the first n_added_vectors() of parameters, followed by any further vectors, which serve as scratch space, otherwise empty

◆ check_consistent_number_of_roots_and_solutions()

template<template< class, class, class > class Solver, class R , class Q , class P >

template<typename TTT >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::check_consistent_number_of_roots_and_solutions	(	const std::vector< TTT > &	roots,
		const size_t	nparams
	)

inlineprotected

◆ check_metric_change()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::check_metric_change	(	MetricKind	kind,
		MetricStorage	storage
	)		const

inlineprotected

Throws if set_metric() with these arguments is not possible, apart from the function applying the metric.

◆ check_metric_positive()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::check_metric_positive ( )

inlineprotected

For a positive (semi)definite metric, throws if the metric matrix shows that it is not, unless checks are off.

◆ check_pspace_metric()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::check_pspace_metric	(	MetricKind	kind,
		const CVecRef< P > &	pparams,
		const array::Span< value_type > &	pp_metric_matrix
	)		const

inlineprotected

Throws if the metric matrix in the P space is not given for a metric of this kind, or, unless checks are off, shows that the metric does not have the properties of its kind; checked before the P space is added.

◆ clearP()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::clearP ( )

inlineoverride

◆ combine_errors()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::combine_errors ( )

inlineprotectedvirtual

Implementation class can overload this to combine the errors of solutions, once those of all are known.

Reimplemented in molpro::linalg::itsolv::LinearEigensystemDavidson< R, Q, P >.

◆ compute_errors()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::compute_errors	(	const std::vector< int > &	roots,
		const CVecRef< R > &	params,
		const CVecRef< R > &	residuals,
		const std::vector< value_type_abs > &	solution_norms,
		std::vector< value_type_abs > &	errors
	)

inlineprotectedvirtual

Computes the errors of roots, given their parameters and residuals; by default the norms of the residuals.

Parameters

solution_norms the Euclidean norms of all solutions if there is a metric, otherwise empty. The errors are then those of the solutions scaled to unit length.

◆ construct_actions()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::construct_actions	(	const std::vector< int > &	rows,
		const subspace::Matrix< value_type > &	solutions,
		const VecRef< R > &	actions
	)

inlineprotected

Constructs the actions on the subspace vectors with the coefficients in the given rows of solutions.

Parameters

rows	rows of solutions
solutions	coefficients of subspace vectors in the current subspace, one vector per row
actions	receives the actions on the subspace vectors

◆ construct_residual()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::construct_residual	(	const std::vector< int > &	roots,
		const CVecRef< R > &	params,
		const VecRef< R > &	actions,
		const detail::MetricSolutions< R, Q > &	metric_solutions
	)

protectedpure virtual

Constructs residual for given roots provided their parameters and actions.

Parameters

metric_solutions the actions of the metric on params if it is applied on the fly, otherwise empty

Implemented in molpro::linalg::itsolv::LinearEigensystemDavidson< R, Q, P >, molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >, molpro::linalg::itsolv::LinearEquationsDavidson< R, Q, P >, molpro::linalg::itsolv::NonLinearEquationsDIIS< R, Q, P >, molpro::linalg::itsolv::OptimizeBFGS< R, Q, P >, and molpro::linalg::itsolv::OptimizeSD< R, Q, P >.

◆ construct_solutions()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::construct_solutions	(	const std::vector< int > &	rows,
		const subspace::Matrix< value_type > &	solutions,
		const VecRef< R > &	parameters
	)

inlineprotected

Constructs the subspace vectors with the coefficients in the given rows of solutions.

Parameters

rows	rows of solutions
solutions	coefficients of subspace vectors in the current subspace, one vector per row
parameters	receives the subspace vectors

◆ convergence_threshold()

template<template< class, class, class > class Solver, class R , class Q , class P >

value_type_abs molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::convergence_threshold ( ) const

inlineoverride

◆ convergence_threshold_value()

template<template< class, class, class > class Solver, class R , class Q , class P >

value_type_abs molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::convergence_threshold_value ( ) const

inlineoverride

◆ current_values()

template<template< class, class, class > class Solver, class R , class Q , class P >

std::vector< scalar_type > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::current_values ( ) const

inline

The values reported in the iteration events: eigenvalues of eigensystems, the function value otherwise.

◆ dimensions()

template<template< class, class, class > class Solver, class R , class Q , class P >

const subspace::Dimensions & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::dimensions ( ) const

inlineoverride

Access dimensions of the subspace.

◆ end_iteration_needed()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::end_iteration_needed ( )

inlineoverrideprotected

◆ errors()

template<template< class, class, class > class Solver, class R , class Q , class P >

const std::vector< value_type_abs > & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::errors ( ) const

inlineoverride

◆ finalize()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::finalize ( )

inlineoverrideprotected

◆ generate_initial_guess_from_diagonals()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::generate_initial_guess_from_diagonals	(	const VecRef< R > &	parameters,
		const Q &	diagonals
	)

inlineprotected

Fills parameters with unit vectors at the positions of the lowest diagonal elements.

One vector is generated per root in the working set, as far as parameters can hold them; with an empty working set nothing is generated.

◆ get_check_metric()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::get_check_metric ( ) const

inlineoverride

◆ get_max_iter()

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::get_max_iter ( ) const

inlineoverride

◆ get_max_p()

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::get_max_p ( ) const

inlineoverride

◆ get_options()

template<template< class, class, class > class Solver, class R , class Q , class P >

std::shared_ptr< Options > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::get_options ( ) const

inlineoverride

◆ get_p_threshold()

template<template< class, class, class > class Solver, class R , class Q , class P >

value_type_abs molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::get_p_threshold ( ) const

inlineoverride

◆ get_verbosity()

template<template< class, class, class > class Solver, class R , class Q , class P >

Verbosity molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::get_verbosity ( ) const

inlineoverride

◆ initialise_pspace()

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::initialise_pspace	(	const std::vector< P > &	pspace,
		const Problem< R > &	problem,
		std::pair< std::vector< value_type >, std::vector< value_type > > &	matrices,
		const VecRef< R > &	parameters,
		const VecRef< R > &	actions
	)

inlineprotected

Adds the P space to the subspace with the matrices of pspace_problem_matrices(); returns the working-set size.

◆ iteration_report()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::iteration_report ( ) const

inline

◆ linearEigensystem()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::linearEigensystem ( ) const

inlineprotectedvirtual

Reimplemented in molpro::linalg::itsolv::LinearEigensystemRSPT< R, Q, P >.

◆ logger()

template<template< class, class, class > class Solver, class R , class Q , class P >

Logger & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::logger ( )

inlineoverride

◆ metric_kind()

template<template< class, class, class > class Solver, class R , class Q , class P >

MetricKind molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::metric_kind ( ) const

inlineoverride

◆ metric_storage()

template<template< class, class, class > class Solver, class R , class Q , class P >

MetricStorage molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::metric_storage ( ) const

inlineoverride

◆ n_added_vectors()

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::n_added_vectors ( const VecRef< R > & parameters ) const

inlineprotected

The number of the given parameters that add_vector() takes up: no more than there are in the working set.

◆ n_roots()

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::n_roots ( ) const

inlineoverride

◆ operator=() [1/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

IterativeSolverTemplate< Solver, R, Q, P > & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::operator= ( const IterativeSolverTemplate< Solver, R, Q, P > & )

delete

◆ operator=() [2/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

IterativeSolverTemplate< Solver, R, Q, P > & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::operator= ( IterativeSolverTemplate< Solver, R, Q, P > && )

defaultnoexcept

◆ prepare_solve()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::prepare_solve	(	const Problem< R > &	problem,
		const VecRef< R > &	actions
	)

inlineprotectedvirtual

Prepares solving problem in solve(), after the problem has been checked and before the solver changes, e.g. by taking over data of the problem.

Parameters

problem	the problem to be solved
actions	buffers that may be used as scratch space

Reimplemented in molpro::linalg::itsolv::LinearEquationsDavidson< R, Q, P >.

◆ profiler()

template<template< class, class, class > class Solver, class R , class Q , class P >

const std::shared_ptr< molpro::profiler::Profiler > & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::profiler ( ) const

inlineoverride

◆ pspace_problem_matrices()

template<template< class, class, class > class Solver, class R , class Q , class P >

std::pair< std::vector< value_type >, std::vector< value_type > > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::pspace_problem_matrices	(	const std::vector< P > &	pspace,
		const Problem< R > &	problem,
		const bool	metric,
		const bool	store_metric_actions
	)		const

inlineprotected

Adds the P space to the subspace using the P-space kernel provided by problem; returns the working-set size.

The kernel and, for a problem with a metric, metric matrices of the problem in the P space, obtained and checked before the solver changes, so that a problem without them, or with an unsuitable metric, is rejected first. Where the actions of the metric are stored, also checks that the problem provides p_metric_action(), by calling it without any vectors.

◆ report() [1/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::report ( ) const

inlineoverride

◆ report() [2/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::report	(	std::ostream &	cout,
		bool	endl = `true`
	)		const

inlineoverride

◆ select_pspace()

template<template< class, class, class > class Solver, class R , class Q , class P >

std::vector< P > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::select_pspace ( const Q & diagonals )

inlineprotected

Selects the P space from the lowest diagonal elements, subject to max_p and p_threshold.

Parameters

diagonals the diagonal elements or, for a generalised eigenproblem, their ratios with those of the metric

Returns: the P-space vectors, empty if fewer than n_roots() elements were selected

◆ set_check_metric()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_check_metric ( bool check )

inlineoverride

◆ set_convergence_threshold()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_convergence_threshold ( value_type_abs thresh )

inlineoverride

◆ set_convergence_threshold_value()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_convergence_threshold_value ( value_type_abs thresh )

inlineoverride

◆ set_logger()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_logger ( std::shared_ptr< Logger > logger )

inlineoverride

◆ set_max_iter()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_max_iter ( int n )

inlineoverride

◆ set_max_p()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_max_p ( int n )

inlineoverride

◆ set_metric()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_metric	(	MetricKind	kind,
		MetricStorage	storage = `MetricStorage::Stored`,
		fapply_metric_type	apply_metric = `{}`
	)

inlineoverride

◆ set_n_roots()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_n_roots ( size_t roots )

inlineoverride

◆ set_options()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_options ( const Options & options )

inlineoverride

◆ set_p_threshold()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_p_threshold ( value_type_abs threshold )

inlineoverride

◆ set_profiler() [1/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_profiler ( molpro::profiler::Profiler & profiler )

inlineoverride

◆ set_profiler() [2/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_profiler ( std::shared_ptr< molpro::profiler::Profiler > profiler )

inlineoverride

◆ set_value_errors()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_value_errors ( )

inlineprotectedvirtual

Implementation class should overload this to set errors in the current values (e.g. change in eigenvalues)

Reimplemented in molpro::linalg::itsolv::DavidsonCommon< Solver, R, Q, P >, molpro::linalg::itsolv::DavidsonCommon< LinearEigensystem, R, R, std::map< size_t, typename R::value_type > >, molpro::linalg::itsolv::DavidsonCommon< LinearEquations, R, R, std::map< size_t, typename R::value_type > >, molpro::linalg::itsolv::OptimizeBFGS< R, Q, P >, and molpro::linalg::itsolv::OptimizeSD< R, Q, P >.

◆ set_verbosity() [1/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_verbosity ( int v )

inlineoverride

◆ set_verbosity() [2/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::set_verbosity ( Verbosity v )

inlineoverride

◆ solution() [1/3]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution	(	const std::vector< int > &	roots,
		const VecRef< R > &	parameters,
		const VecRef< R > &	residual
	)

inlineoverride

◆ solution() [2/3]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution	(	const std::vector< int > &	roots,
		std::vector< R > &	parameters,
		std::vector< R > &	residual
	)

inlineoverride

◆ solution() [3/3]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution	(	R &	parameters,
		R &	residual
	)

inlineoverride

◆ solution_impl() [1/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution_impl	(	const std::vector< int > &	roots,
		const VecRef< R > &	parameters,
		const VecRef< R > &	residual,
		const VecRef< R > &	scratch
	)

inlineprotected

Implements solution()

Parameters

scratch R vectors that may be overwritten, for the actions of a metric applied on the fly; if there are fewer than roots, Q vectors are used instead

◆ solution_impl() [2/2]

template<template< class, class, class > class Solver, class R , class Q , class P >

template<typename ConstructResidual >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution_impl	(	const std::vector< int > &	roots,
		const VecRef< R > &	parameters,
		const VecRef< R > &	residual,
		const VecRef< R > &	scratch,
		ConstructResidual &&	construct_residual_with
	)

inlineprotected

Implements solution(), with the residuals constructed by the given function in place of construct_residual(), which takes the same arguments.

◆ solution_params() [1/3]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution_params	(	const std::vector< int > &	roots,
		const VecRef< R > &	parameters
	)

inlineoverride

◆ solution_params() [2/3]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution_params	(	const std::vector< int > &	roots,
		std::vector< R > &	parameters
	)

inlineoverride

◆ solution_params() [3/3]

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution_params ( R & parameters )

inlineoverride

◆ solution_with_errors()

template<template< class, class, class > class Solver, class R , class Q , class P >

virtual void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solution_with_errors	(	const std::vector< int > &	roots,
		const VecRef< R > &	parameters,
		const VecRef< R > &	residual,
		const VecRef< R > &	scratch,
		const std::vector< value_type_abs > &	solution_norms,
		std::vector< value_type_abs > &	errors
	)

inlineprotectedvirtual

Constructs the parameters and residuals of roots, as solution_impl() does, and computes their errors, as compute_errors() does.

Reimplemented in molpro::linalg::itsolv::LinearEigensystemDavidson< R, Q, P >.

◆ solve() [1/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solve	(	const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		const Problem< R > &	problem,
		bool	generate_initial_guess = `false`
	)

inlineoverride

◆ solve() [2/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solve	(	const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		const VecRef< R > &	metric_actions,
		const Problem< R > &	problem,
		bool	generate_initial_guess = `false`
	)

inlineoverride

◆ solve() [3/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solve	(	R &	parameters,
		R &	actions,
		const Problem< R > &	problem,
		bool	generate_initial_guess = `false`
	)

inlineoverride

◆ solve() [4/4]

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solve	(	std::vector< R > &	parameters,
		std::vector< R > &	actions,
		const Problem< R > &	problem,
		bool	generate_initial_guess = `false`
	)

inlineoverride

◆ solve_and_generate_working_set()

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solve_and_generate_working_set	(	const VecRef< R > &	parameters,
		const VecRef< R > &	action,
		const VecRef< R > &	scratch = `{}`
	)

inlineprotected

Solves the subspace problems and selects the working set of roots, returning their parameters and residual in parameters and action.

Parameters

parameters	container for storing parameters of the working set
action	container for storing the residual of the working set
scratch	vectors that may be overwritten, see solution_impl()

Returns: size of the working set

◆ solve_impl()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::solve_impl	(	const VecRef< R > &	parameters,
		const VecRef< R > &	actions,
		const VecRef< R > &	metric_actions,
		const Problem< R > &	problem,
		bool	generate_initial_guess
	)

inlineprotected

Implements both overloads of solve(), with empty metric_actions for a problem without a metric.

◆ statistics()

template<template< class, class, class > class Solver, class R , class Q , class P >

const Statistics & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::statistics ( ) const

inlineoverride

◆ suggest_p()

template<template< class, class, class > class Solver, class R , class Q , class P >

std::vector< size_t > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::suggest_p	(	const CVecRef< R > &	solution,
		const CVecRef< R > &	residual,
		size_t	max_number,
		value_type_abs	threshold
	)

inlineoverride

◆ summary_report()

template<template< class, class, class > class Solver, class R , class Q , class P >

void molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::summary_report ( ) const

inline

◆ supports_metric()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::supports_metric ( MetricKind kind ) const

inlineoverride

◆ test_metric()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::test_metric	(	const Problem< R > &	problem,
		R &	v0,
		R &	v1,
		int	verbosity,
		value_type_abs	threshold
	)		const

inlineprotected

Tests that the metric of a problem is Hermitian, <u|M v> = <M u|v>, and, if its kind says so, positive (semi)definite, on the first two test parameters.

Returns: false if errors were found, otherwise true

◆ test_problem()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::test_problem	(	const Problem< R > &	problem,
		R &	v0,
		R &	v1,
		int	verbosity,
		value_type_abs	threshold
	)		const

inlineoverride

◆ value()

template<template< class, class, class > class Solver, class R , class Q , class P >

scalar_type molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::value ( ) const

inlineoverride

◆ verbosity_at_least()

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::verbosity_at_least ( Verbosity v ) const

inlineprotected

Whether output of verbosity v is printed in solve(); everything is printed if no verbosity was set.

◆ working_set()

template<template< class, class, class > class Solver, class R , class Q , class P >

const std::vector< int > & molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::working_set ( ) const

inlineoverride

Member Data Documentation

◆ m_apply_metric

template<template< class, class, class > class Solver, class R , class Q , class P >

fapply_metric_type molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_apply_metric = {}

protected

applies the metric on the fly, if its actions are not stored

◆ m_apply_metric_p

template<template< class, class, class > class Solver, class R , class Q , class P >

fapply_on_p_type molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_apply_metric_p = {}

protected

adds the action of the metric on the P space, if its actions are stored

◆ m_apply_p

template<template< class, class, class > class Solver, class R , class Q , class P >

fapply_on_p_type molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_apply_p = {}

protected

function that evaluates effect of action on the P space projection

◆ m_check_metric

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_check_metric = true

protected

whether the properties of the metric are checked

◆ m_convergence_threshold

template<template< class, class, class > class Solver, class R , class Q , class P >

value_type_abs molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_convergence_threshold {1.0e-8}

protected

residual norms less than this mark a converged solution

◆ m_convergence_threshold_value

template<template< class, class, class > class Solver, class R , class Q , class P >

value_type_abs molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_convergence_threshold_value

protected

Initial value:

{

std::numeric_limits<value_type_abs>::max()}

value changes less than this mark a converged solution

◆ m_end_iteration_needed

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_end_iteration_needed = true

protected

whether end_iteration should be called after any preconditioner

◆ m_errors

template<template< class, class, class > class Solver, class R , class Q , class P >

std::vector<value_type_abs> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_errors

protected

errors from the most recent solution

◆ m_handlers

template<template< class, class, class > class Solver, class R , class Q , class P >

std::shared_ptr<ArrayHandlers<R, Q, P> > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_handlers

protected

Array handlers.

◆ m_logger

template<template< class, class, class > class Solver, class R , class Q , class P >

std::shared_ptr<Logger> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_logger

protected

logger

◆ m_max_iter

template<template< class, class, class > class Solver, class R , class Q , class P >

int molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_max_iter = 100

protected

maximum number of iterations in solve()

◆ m_max_p

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_max_p = 0

protected

maximum size of P space

◆ m_metric_checker

template<template< class, class, class > class Solver, class R , class Q , class P >

detail::MetricChecker<R, Q, P> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_metric_checker

protected

checks the properties of the metric

◆ m_metric_kind

template<template< class, class, class > class Solver, class R , class Q , class P >

MetricKind molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_metric_kind = MetricKind::Identity

protected

the metric declared with set_metric()

◆ m_metric_storage

template<template< class, class, class > class Solver, class R , class Q , class P >

MetricStorage molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_metric_storage = MetricStorage::Stored

protected

how the actions of the metric are obtained

◆ m_nroots

template<template< class, class, class > class Solver, class R , class Q , class P >

size_t molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_nroots {0}

protected

number of roots the solver is searching for

◆ m_p_threshold

template<template< class, class, class > class Solver, class R , class Q , class P >

value_type_abs molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_p_threshold = std::numeric_limits<value_type_abs>::max()

protected

threshold for selecting P space

◆ m_solutions_outdated

template<template< class, class, class > class Solver, class R , class Q , class P >

bool molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_solutions_outdated = false

protected

whether the subspace was changed since the solutions of its problem were found

◆ m_stats

template<template< class, class, class > class Solver, class R , class Q , class P >

std::shared_ptr<Statistics> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_stats

protected

accumulates statistics of operations performed by the solver

◆ m_subspace_solver

template<template< class, class, class > class Solver, class R , class Q , class P >

std::shared_ptr<subspace::ISubspaceSolver<R, Q, P> > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_subspace_solver

protected

solves the subspace problem

◆ m_value_errors

template<template< class, class, class > class Solver, class R , class Q , class P >

std::vector<value_type_abs> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_value_errors

protected

value errors from the most recent solution

◆ m_verbosity

template<template< class, class, class > class Solver, class R , class Q , class P >

std::optional<Verbosity> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_verbosity = {}

protected

how much output to print in solve()

◆ m_working_set

template<template< class, class, class > class Solver, class R , class Q , class P >

std::vector<int> molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_working_set

protected

indices of roots in the working set

◆ m_xspace

template<template< class, class, class > class Solver, class R , class Q , class P >

std::shared_ptr<subspace::IXSpace<R, Q, P> > molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >::m_xspace

protected

manages the subspace and associated data

Detailed Description

Public Member Functions

Protected Member Functions

Protected Attributes

Constructor & Destructor Documentation

◆ IterativeSolverTemplate() [1/4]

◆ IterativeSolverTemplate() [2/4]

◆ IterativeSolverTemplate() [3/4]

◆ IterativeSolverTemplate() [4/4]

◆ ~IterativeSolverTemplate()

Member Function Documentation

◆ add_p() [1/2]

◆ add_p() [2/2]

◆ add_p_impl()

◆ add_vector() [1/4]

◆ add_vector() [2/4]

◆ add_vector() [3/4]

◆ add_vector() [4/4]

◆ add_vector_impl()

◆ check_consistent_number_of_roots_and_solutions()

◆ check_metric_change()

◆ check_metric_positive()

◆ check_pspace_metric()

◆ clearP()

◆ combine_errors()

◆ compute_errors()

◆ construct_actions()

◆ construct_residual()

◆ construct_solutions()

◆ convergence_threshold()

◆ convergence_threshold_value()

◆ current_values()

◆ dimensions()

◆ end_iteration_needed()

◆ errors()

◆ finalize()

◆ generate_initial_guess_from_diagonals()

◆ get_check_metric()

◆ get_max_iter()

◆ get_max_p()

◆ get_options()

◆ get_p_threshold()

◆ get_verbosity()

◆ initialise_pspace()

◆ iteration_report()

◆ linearEigensystem()

◆ logger()

◆ metric_kind()

◆ metric_storage()

◆ n_added_vectors()

◆ n_roots()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ prepare_solve()

◆ profiler()

◆ pspace_problem_matrices()

◆ report() [1/2]

◆ report() [2/2]

◆ select_pspace()

◆ set_check_metric()

◆ set_convergence_threshold()

◆ set_convergence_threshold_value()

◆ set_logger()

◆ set_max_iter()

◆ set_max_p()

◆ set_metric()

◆ set_n_roots()

◆ set_options()

◆ set_p_threshold()

◆ set_profiler() [1/2]

◆ set_profiler() [2/2]

◆ set_value_errors()

◆ set_verbosity() [1/2]

◆ set_verbosity() [2/2]

◆ solution() [1/3]

◆ solution() [2/3]

◆ solution() [3/3]

◆ solution_impl() [1/2]

◆ solution_impl() [2/2]

◆ solution_params() [1/3]