Utils_AlgoHNewton.hh

Go to the documentation of this file.

/*--------------------------------------------------------------------------*\
 |                                                                          |
 |  Copyright (C) 2025                                                      |
 |                                                                          |
 |         , __                 , __                                        |
 |        /|/  \               /|/  \                                       |
 |         | __/ _   ,_         | __/ _   ,_                                |
 |         |   \|/  /  |  |   | |   \|/  /  |  |   |                        |
 |         |(__/|__/   |_/ \_/|/|(__/|__/   |_/ \_/|/                       |
 |                           /|                   /|                        |
 |                           \|                   \|                        |
 |                                                                          |
 |      Enrico Bertolazzi                                                   |
 |      Dipartimento di Ingegneria Industriale                              |
 |      Università degli Studi di Trento                                    |
 |      email: enrico.bertolazzi@unitn.it                                   |
 |                                                                          |
\*--------------------------------------------------------------------------*/
 
//
// file: Utils_HNewton.hh
//
 
#pragma once
 
#ifndef UTILS_ALGO_HNEWTON_dot_HH
#define UTILS_ALGO_HNEWTON_dot_HH
 
#include <iostream>
#include <sstream>
#include <string>
#include <algorithm>
#include <cmath>
 
#include "Utils.hh"
 
namespace Utils {
 
  using std::pow;
  using std::abs;

 
  /*
  //   _   _ _   _               _
  //  | | | | \ | | _____      _| |_ ___  _ __
  //  | |_| |  \| |/ _ \ \ /\ / / __/ _ \| '_ \
  //  |  _  | |\  |  __/\ V  V /| || (_) | | | |
  //  |_| |_|_| \_|\___| \_/\_/  \__\___/|_| |_|
  */

  template <typename Real>
  class AlgoHNewton_base_fun {
  public:
    virtual Real eval( Real x ) const = 0;
    virtual Real D( Real x ) const = 0;
  };
 
  #ifndef DOXYGEN_SHOULD_SKIP_THIS
  template <typename Real, typename PFUN, typename PFUN_D>
  class AlgoHNewton_fun : public AlgoHNewton_base_fun<Real> {
    PFUN   m_fun;
    PFUN_D m_fun_D;
  public:
    explicit AlgoHNewton_fun( PFUN f, PFUN_D Df ) : m_fun(f), m_fun_D(Df) {}
    Real eval( Real x ) const override { return m_fun(x); };
    Real D   ( Real x ) const override { return m_fun_D(x); };
  };
  #endif

  template <typename Real>
  class AlgoHNewton {
 
    using Integer = int;
 
    Real m_tolerance{pow(machine_eps<Real>(),Real(2./3.))};
    bool m_converged{false};
 
    Real m_a{0}, m_fa{0};
    Real m_b{0}, m_fb{0};
    Real m_c{0}, m_fc{0};
    Real m_d{0}, m_fd{0};
    Real m_ba{0};
    Real m_kappa{0.05};
 
    AlgoHNewton_base_fun<Real> const * m_function{nullptr};
 
    Integer m_max_iteration{200}; // max number of iterations
 
    mutable Integer m_iteration_count{0};    // explore iteration counter
    mutable Integer m_fun_evaluation_count{0};
    mutable Integer m_fun_D_evaluation_count{0};
 
    Real evaluate  ( Real x ) const { ++m_fun_evaluation_count;   return m_function->eval(x); };
    Real evaluate_D( Real x ) const { ++m_fun_D_evaluation_count; return m_function->D(x);    };
 
    Real eval();
    Real eval( Real a, Real b );
    Real eval( Real a, Real b, Real amin, Real bmax );
 
    void set_tolerance( Real tol );
 
    Real p_zero2() const;
    Real invp_zero2() const;
    Real invp_zero3() const;
 
  public:
 
    AlgoHNewton() = default;
    ~AlgoHNewton() = default;

    Real
    eval( Real a, Real b, AlgoHNewton_base_fun<Real> const * fun ) {
      m_function = fun;
      return this->eval( a, b );
    }

    Real
    eval( Real a, Real b, Real amin, Real bmax, AlgoHNewton_base_fun<Real> const * fun ) {
      m_function = fun;
      return this->eval( a, b, amin, bmax );
    }

    void set_max_iterations( Integer mit );

    Integer used_iter() const { return m_iteration_count; }

    Integer num_fun_eval() const { return m_fun_evaluation_count; }

    Integer num_fun_D_eval() const { return m_fun_D_evaluation_count; }

    Real tolerance() const { return m_tolerance; }

    bool converged() const { return m_converged; }
 
    Real a()  const { return m_a; }
    Real b()  const { return m_b; }
    Real fa() const { return m_fa; }
    Real fb() const { return m_fb; }
 
  };
 
  #ifndef UTILS_OS_WINDOWS
  extern template class AlgoHNewton<float>;
  extern template class AlgoHNewton<double>;
  #endif

 
}
 
#endif
 
//
// EOF: Utils_AlgoHNewton.hh
//