Bracketing.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco, Mattia Piazza and Enrico Bertolazzi.                       *
 *                                                                                               *
 * The Optimist project is distributed under the BSD 2-Clause License.                           *
 *                                                                                               *
 * Davide Stocco                          Mattia Piazza                        Enrico Bertolazzi *
 * University of Trento               University of Trento                  University of Trento *
 * davide.stocco@unitn.it            mattia.piazza@unitn.it           enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef OPTIMIST_ROOTFINDER_BRACKTING_HH
#define OPTIMIST_ROOTFINDER_BRACKTING_HH
 
#include "Optimist/RootFinder.hh"
 
namespace Optimist
{
  namespace RootFinder
  {
 
    /*\
     |   ____                 _        _   _
     |  | __ ) _ __ __ _  ___| | _____| |_(_)_ __   __ _
     |  |  _ \| '__/ _` |/ __| |/ / _ \ __| | '_ \ / _` |
     |  | |_) | | | (_| | (__|   <  __/ |_| | | | | (_| |
     |  |____/|_|  \__,_|\___|_|\_\___|\__|_|_| |_|\__, |
     |                                             |___/
    \*/

    template <typename Real, typename DerivedSolver>
    class Bracketing : public RootFinder<Real, 1, DerivedSolver>
    {
    public:
      static constexpr bool requires_function{DerivedSolver::requires_function};
      static constexpr bool requires_first_derivative{DerivedSolver::requires_first_derivative};
      static constexpr bool requires_second_derivative{DerivedSolver::requires_second_derivative};
 
      OPTIMIST_BASIC_CONSTANTS(Real) 
 
      // Function types
      using FunctionWrapper         = typename RootFinder<Real, 1, DerivedSolver>::FunctionWrapper;
      using FirstDerivativeWrapper  = typename RootFinder<Real, 1, DerivedSolver>::FirstDerivativeWrapper;
      using SecondDerivativeWrapper = typename RootFinder<Real, 1, DerivedSolver>::SecondDerivativeWrapper;
 
    protected:
      Real m_tolerance_bracketing{100*EPSILON}; 
      Real m_mu{0.5}; 
      Real m_interval_shink{0.025}; 
 
      Real m_a{0.0}, m_fa{0.0};
      Real m_b{0.0}, m_fb{0.0};
      Real m_c{0.0}, m_fc{0.0};
      Real m_d{0.0}, m_fd{0.0};
      Real m_e{0.0}, m_fe{0.0};
 
    public:
      Bracketing() {}

      std::string name_impl() const
      {
        return static_cast<const DerivedSolver *>(this)->name_impl();
      }

      void tolerance_bracketing(Real t_tolerance) {this->m_tolerance_bracketing = t_tolerance;}

      bool solve_impl(FunctionWrapper function, Real /*x_ini*/, Real & x_sol)
      {
        // Setup internal variables
        this->reset();
 
        // Print header
        if (this->m_verbose) {this->header();}
 
        // Initialize variables
        this->m_a = this->m_lower_bound; this->evaluate_function(function, this->m_a, this->m_fa);
        this->m_b = this->m_upper_bound; this->evaluate_function(function, this->m_b, this->m_fb);
 
        // Check if the solution exists
        if (this->m_fa*this->m_fb > 0.0) {return false;}
        else {x_sol = this->find_root(function);}
 
        // Print bottom
        if (this->m_verbose) {this->bottom();}
 
        // Convergence data
        return this->m_converged;
      }

      Real find_root(FunctionWrapper function)
      {
        return static_cast<DerivedSolver *>(this)->find_root_impl(function);
      }
 
    }; // class Bracketing
 
  } // namespace RootFinder
 
} // namespace Optimist
 
#endif // OPTIMIST_ROOTFINDER_BRACKTING_HH