gsMinimalResidual.h

Go to the documentation of this file.

 
#pragma once
 
#include <gsSolver/gsIterativeSolver.h>
 
namespace gismo
{
 
template<class T=real_t>
class gsMinimalResidual : public gsIterativeSolver<T>
{
 
public:
    typedef gsIterativeSolver<T> Base;
 
    typedef gsMatrix<T>  VectorType;
 
    typedef typename Base::LinOpPtr LinOpPtr;
 
    typedef memory::shared_ptr<gsMinimalResidual> Ptr;
    typedef memory::unique_ptr<gsMinimalResidual> uPtr;
 
    template< typename OperatorType >
    explicit gsMinimalResidual( const OperatorType& mat,
                                const LinOpPtr& precond = LinOpPtr())
        : Base(mat, precond), m_inexact_residual(false) {}
 
    template< typename OperatorType >
    static uPtr make( const OperatorType& mat, const LinOpPtr& precond = LinOpPtr() )
    { return uPtr( new gsMinimalResidual(mat, precond) ); }
 
    bool initIteration( const VectorType& rhs, VectorType& x );
    void finalizeIteration( VectorType& x );
 
    bool step( VectorType& x );
 
    static gsOptionList defaultOptions()
    {
        gsOptionList opt = Base::defaultOptions();
        opt.addSwitch( "InexactResidual",
                       "If true, the residual is estimated, not accurately computed.",
                       false );
        return opt;
    }
 
    gsMinimalResidual& setOptions(const gsOptionList & opt)
    {
        Base::setOptions(opt);
        m_inexact_residual = opt.askSwitch("InexactResidual", m_inexact_residual);
        return *this;
    }
 
    void setInexactResidual( bool flag )     { m_inexact_residual = flag; }
 
    std::ostream &print(std::ostream &os) const
    {
        os << "gsMinimalResidual\n";
        return os;
    }
 
private:
    using Base::m_mat;
    using Base::m_precond;
    using Base::m_max_iters;
    using Base::m_tol;
    using Base::m_num_iter;
    using Base::m_rhs_norm;
    using Base::m_error;
 
    gsMatrix<T> negResidual,
                     vPrev, v, vNew,
                     wPrev, w, wNew, AwPrev, Aw, AwNew,
                     zNew, z, Az;
 
    T eta,
           gammaPrev, gamma, gammaNew,
           sPrev, s, sNew,
           cPrev, c, cNew;
 
    bool m_inexact_residual;
};
 
} // namespace gismo
 
#ifndef GISMO_BUILD_LIB
#include GISMO_HPP_HEADER(gsMinimalResidual.hpp)
#endif