newton.hh

Go to the documentation of this file.

 
#ifndef newton_hh
#define newton_hh
 
#include <type_traits>
#include "basics/debug.hh"
 
#define NEWTON_CONST_D 0
 
 
#if defined(__clang__)
#include <functional>
#endif
 
#if defined(__GNUC__)
#if __GNUC__ >= 7
#include <functional>
#endif
#endif
 
namespace concepts
{
  // ****************************************************** Newton **
 
  template<class F>
  class Newton: public VecOperator<typename F::d_type >
  {
  public:
 
    typename F::d_type type;
 
#include "basics/warnings/push.h"
#include "basics/warnings/ignore_warning_dangling_field.h"
    Newton(std::function<Vector<typename F::d_type>(Vector<typename F::d_type>)> A, Real dx, uint dimY, uint dimX,
           Real tol = 1e-8, Real iterMax = 1000) :
      VecOperator<typename F::d_type>(dimY, dimX), A_(A), JacA_(nullptr), definedJacA_(false), dx_(dx), dimY_(dimY), dimX_(dimX),
      tol_(tol), iterMax_(iterMax), verbose_(false), linearSolver_(nullptr) {
      DEBUGL(NEWTON_CONST_D, "Newton solver with implicit computation of the Jacobian built");
    };
 
    Newton(std::function<Vector<typename F::d_type >(Vector<typename F::d_type>)> A, std::function<F(Vector<typename F::d_type>)> JacA, uint dimY,
           uint dimX, Real tol = 1e-8, Real iterMax = 50) :
      VecOperator<typename F::d_type>(dimY, dimX), A_(A), JacA_(&JacA), definedJacA_(true), dx_(0.), dimY_(dimY), dimX_(dimX),
      tol_(tol), iterMax_(iterMax), verbose_(false), linearSolver_(nullptr) {
      DEBUGL(NEWTON_CONST_D, "Newton solver with explicit Jacobian built");
    };
#include "basics/warnings/pop.h"
 
    virtual ~Newton() {};
 
    virtual void show_messages();
 
    virtual void hide_messages();
 
    virtual void apply_(const Vector<typename F::d_type>& fncY,
                        Vector<typename F::d_type>& fncX);
 
    virtual void apply_();
 
  protected:
 
#include "basics/warnings/push.h"
#include "basics/warnings/ignore_warning_dangling_field.h"
    
    std::function<Vector<typename F::d_type>(Vector<typename F::d_type>)>& A_;
 
    std::function<F(Vector<typename F::d_type>)>* JacA_;
 
#include "basics/warnings/pop.h"
 
    bool definedJacA_;
 
    Real dx_;
 
    uint dimY_;
 
    uint dimX_;
 
    Real tol_;
 
    uint iterMax_;
 
    bool verbose_;
    
    std::unique_ptr<concepts::Operator<typename F::d_type> > linearSolver_;
 
    virtual void setLinearSolver_(F* Jacobian);
 
  };
}
 
#endif