A class that optimises a function using a simple steepest-descent method. More...

#include <OptimizeSD.h>

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

Collaboration diagram for molpro::linalg::itsolv::OptimizeSD< R, Q, P >:

Detailed Description

template<class R, class Q = R, class P = std::map<size_t, typename R::value_type>>
class molpro::linalg::itsolv::OptimizeSD< R, Q, P >

A class that optimises a function using a simple steepest-descent method.

Template Parameters

R	The class encapsulating solution and residual vectors
Q	Used internally as a class for storing vectors on backing store

Public Types
using	SolverTemplate = IterativeSolverTemplate< Optimize, R, Q, P >

using	SubspaceSolver = subspace::SubspaceSolverOptSD< R, Q, P >

Public Member Functions
	OptimizeSD (const std::shared_ptr< ArrayHandlers< R, Q, P > > &handlers, const std::shared_ptr< Logger > &logger_=std::make_shared< Logger >())

bool	nonlinear () const override

size_t	end_iteration (const VecRef< R > &parameters, const VecRef< R > &action) override

size_t	end_iteration (std::vector< R > &parameters, std::vector< R > &action) override

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

void	set_options (const Options &options) override

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

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

int	add_vector (R &parameters, R &residual, value_type value) override

size_t	end_iteration (R &parameters, R &actions) override

Public Member Functions inherited from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >
	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
void	construct_residual (const std::vector< int > &roots, const CVecRef< R > &params, const VecRef< R > &actions, const detail::MetricSolutions< R, Q > &metric_solutions) override
	Constructs residual for given roots provided their parameters and actions.

Protected Member Functions inherited from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >
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	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.

Additional Inherited Members
Protected Attributes inherited from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >
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

Member Typedef Documentation

◆ SolverTemplate

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

using molpro::linalg::itsolv::OptimizeSD< R, Q, P >::SolverTemplate = IterativeSolverTemplate<Optimize, R, Q, P>

◆ SubspaceSolver

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

using molpro::linalg::itsolv::OptimizeSD< R, Q, P >::SubspaceSolver = subspace::SubspaceSolverOptSD<R, Q, P>

Constructor & Destructor Documentation

◆ OptimizeSD()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

molpro::linalg::itsolv::OptimizeSD< R, Q, P >::OptimizeSD	(	const std::shared_ptr< ArrayHandlers< R, Q, P > > &	handlers,
		const std::shared_ptr< Logger > &	logger_ = `std::make_shared<Logger>()`
	)

inlineexplicit

Member Function Documentation

◆ add_vector()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

int molpro::linalg::itsolv::OptimizeSD< R, Q, P >::add_vector	(	R &	parameters,
		R &	residual,
		value_type	value
	)

inlineoverride

◆ construct_residual()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::OptimizeSD< 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
	)

inlineoverrideprotectedvirtual

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

Implements molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >.

◆ end_iteration() [1/3]

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

size_t molpro::linalg::itsolv::OptimizeSD< R, Q, P >::end_iteration	(	const VecRef< R > &	parameters,
		const VecRef< R > &	action
	)

inlineoverride

◆ end_iteration() [2/3]

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

size_t molpro::linalg::itsolv::OptimizeSD< R, Q, P >::end_iteration	(	R &	parameters,
		R &	actions
	)

inlineoverride

◆ end_iteration() [3/3]

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

size_t molpro::linalg::itsolv::OptimizeSD< R, Q, P >::end_iteration	(	std::vector< R > &	parameters,
		std::vector< R > &	action
	)

inlineoverride

◆ get_options()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

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

inlineoverride

◆ nonlinear()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

bool molpro::linalg::itsolv::OptimizeSD< R, Q, P >::nonlinear ( ) const

inlineoverride

◆ report()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

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

inlineoverride

◆ set_options()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

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

inlineoverride

◆ set_value_errors()

template<class R , class Q = R, class P = std::map<size_t, typename R::value_type>>

void molpro::linalg::itsolv::OptimizeSD< R, Q, P >::set_value_errors ( )

inlineoverridevirtual

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

Reimplemented from molpro::linalg::itsolv::IterativeSolverTemplate< Solver, R, Q, P >.

Detailed Description

Public Types

Public Member Functions

Protected Member Functions

Additional Inherited Members

Member Typedef Documentation

◆ SolverTemplate

◆ SubspaceSolver

Constructor & Destructor Documentation

◆ OptimizeSD()

Member Function Documentation

◆ add_vector()

◆ construct_residual()

◆ end_iteration() [1/3]

◆ end_iteration() [2/3]

◆ end_iteration() [3/3]

◆ get_options()

◆ nonlinear()

◆ report()

◆ set_options()

◆ set_value_errors()