Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual. More...

#include <ginkgo/core/solver/ir.hpp>

Collaboration diagram for gko::solver::Ir< ValueType >:

[legend]

Classes
class	Factory

struct	parameters_type

Public Types
using	value_type = ValueType

Public Types inherited from gko::EnablePolymorphicAssignment< Ir< ValueType > >
using	result_type = Ir< ValueType >

Public Types inherited from gko::ConvertibleTo< Ir< ValueType > >
using	result_type = Ir< ValueType >

Public Member Functions
std::shared_ptr< const LinOp >	get_system_matrix () const
	Returns the system operator (matrix) of the linear system. More...

std::shared_ptr< const LinOp >	get_solver () const
	Returns the solver operator used as the inner solver. More...

const parameters_type &	get_parameters () const

Public Member Functions inherited from gko::EnableLinOp< Ir< ValueType > >
const Ir< ValueType > *	apply (const LinOp b, LinOp x) const

Ir< ValueType > *	apply (const LinOp b, LinOp x)

const Ir< ValueType > *	apply (const LinOp alpha, const LinOp b, const LinOp beta, LinOp x) const

Ir< ValueType > *	apply (const LinOp alpha, const LinOp b, const LinOp beta, LinOp x)

Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< Ir< ValueType >, LinOp >
std::unique_ptr< Ir< ValueType > >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< Ir< ValueType > >	create_default () const

std::unique_ptr< Ir< ValueType > >	clone (std::shared_ptr< const Executor > exec) const

std::unique_ptr< Ir< ValueType > >	clone () const

Ir< ValueType > *	copy_from (const PolymorphicObject *other)

Ir< ValueType > *	copy_from (std::unique_ptr< PolymorphicObject > other)

Ir< ValueType > *	clear ()

Public Member Functions inherited from gko::LinOp
LinOp *	apply (const LinOp b, LinOp x)
	Applies a linear operator to a vector (or a sequence of vectors). More...

const LinOp *	apply (const LinOp b, LinOp x) const
	Applies a linear operator to a vector (or a sequence of vectors). More...

LinOp *	apply (const LinOp alpha, const LinOp b, const LinOp beta, LinOp x)
	Performs the operation x = alpha * op(b) + beta * x. More...

const LinOp *	apply (const LinOp alpha, const LinOp b, const LinOp beta, LinOp x) const
	Performs the operation x = alpha * op(b) + beta * x. More...

const dim< 2 > &	get_size () const noexcept
	Returns the size of the operator. More...

Public Member Functions inherited from gko::EnableAbstractPolymorphicObject< LinOp >
std::unique_ptr< LinOp >	create_default (std::shared_ptr< const Executor > exec) const

std::unique_ptr< LinOp >	create_default () const

std::unique_ptr< LinOp >	clone (std::shared_ptr< const Executor > exec) const

std::unique_ptr< LinOp >	clone () const

LinOp *	copy_from (const PolymorphicObject *other)

LinOp *	copy_from (std::unique_ptr< PolymorphicObject > other)

LinOp *	clear ()

Public Member Functions inherited from gko::PolymorphicObject
PolymorphicObject &	operator= (const PolymorphicObject &)

std::unique_ptr< PolymorphicObject >	create_default (std::shared_ptr< const Executor > exec) const
	Creates a new "default" object of the same dynamic type as this object. More...

std::unique_ptr< PolymorphicObject >	create_default () const
	Creates a new "default" object of the same dynamic type as this object. More...

std::unique_ptr< PolymorphicObject >	clone (std::shared_ptr< const Executor > exec) const
	Creates a clone of the object. More...

std::unique_ptr< PolymorphicObject >	clone () const
	Creates a clone of the object. More...

PolymorphicObject *	copy_from (const PolymorphicObject *other)
	Copies another object into this object. More...

PolymorphicObject *	copy_from (std::unique_ptr< PolymorphicObject > other)
	Moves another object into this object. More...

PolymorphicObject *	clear ()
	Transforms the object into its default state. More...

std::shared_ptr< const Executor >	get_executor () const noexcept
	Returns the Executor of the object. More...

Public Member Functions inherited from gko::log::EnableLogging< PolymorphicObject >
void	add_logger (std::shared_ptr< const Logger > logger) override
	Adds a new logger to the list of subscribed loggers. More...

void	remove_logger (const Logger *logger) override
	Removes a logger from the list of subscribed loggers. More...

Public Member Functions inherited from gko::EnablePolymorphicAssignment< Ir< ValueType > >
void	convert_to (result_type *result) const override
	Converts the implementer to an object of type result_type. More...

void	move_to (result_type *result) override
	Converts the implementer to an object of type result_type by moving data from this object. More...

Static Public Member Functions
static auto	build () -> decltype(Factory ::create())

Friends
class	EnableLinOp< Ir >

class	EnablePolymorphicObject< Ir, LinOp >

Detailed Description

template<typename ValueType = default_precision>
class gko::solver::Ir< ValueType >

Iterative refinement (IR) is an iterative method that uses another coarse method to approximate the error of the current solution via the current residual.

For any approximation of the solution solution to the system Ax = b, the residual is defined as: residual = b - A solution. The error in solution, e = x - solution (with x being the exact solution) can be obtained as the solution to the residual equation Ae = residual, since A e = Ax - A solution = b - A solution = residual. Then, the real solution is computed as x = solution + e. Instead of accurately solving the residual equation Ae = residual, the solution of the system e can be approximated to obtain the approximation error using a coarse method solver, which is used to update solution, and the entire process is repeated with the updated solution. This yields the iterative refinement method:

solution = initial_guess
while not converged:
    residual = b - A solution
    error = solver(A, residual)
    solution = solution + error

Assuming that solver has accuracy c, i.e., | e - error | <= c | e |, iterative refinement will converge with a convergence rate of c. Indeed, from e - error = x - solution - error = x - solution* (where solution* denotes the value stored in solution after the update) and e = inv(A) residual = inv(A)b - inv(A) A solution = x - solution it follows that | x - solution* | <= c | x - solution |.

Unless otherwise specified via the solver factory parameter, this implementation uses the identity operator (i.e. the solver that approximates the solution of a system Ax = b by setting x := b) as the default inner solver. Such a setting results in a relaxation method known as the Richardson iteration with parameter 1, which is guaranteed to converge for matrices whose spectrum is strictly contained within the unit disc around 1 (i.e., all its eigenvalues lambda have to satisfy the equation `|lambda - 1| < 1).

Template Parameters

ValueType precision of matrix elements

Member Function Documentation

◆ get_solver()

template<typename ValueType = default_precision>

std::shared_ptr<const LinOp> gko::solver::Ir< ValueType >::get_solver ( ) const

inline

Returns the solver operator used as the inner solver.

Returns: the solver operator used as the inner solver

◆ get_system_matrix()

template<typename ValueType = default_precision>

std::shared_ptr<const LinOp> gko::solver::Ir< ValueType >::get_system_matrix ( ) const

inline

Returns the system operator (matrix) of the linear system.

Returns: the system operator (matrix)

The documentation for this class was generated from the following file:

ginkgo/core/solver/ir.hpp (4bde4271)

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

template<typename ValueType = default_precision> class gko::solver::Ir< ValueType >

Member Function Documentation

◆ get_solver()

◆ get_system_matrix()

template<typename ValueType = default_precision>
class gko::solver::Ir< ValueType >