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:
      OPTIMIST_BASIC_CONSTANTS(Real)
 
    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;}

      template <typename FunctionLambda>
      bool solve_impl(FunctionLambda && function, Real /*x_ini*/, Real & x_sol)
      {
        #define CMD "Optimist::ScalarRootfinder::Bracketing::solve_impl(...): "
 
        // Setup internal variables
        bool success;
        this->reset();
 
        // Print header
        if (this->m_verbose) {this->header();}
 
        // Initialize variables
        this->m_a = this->m_lower_bound;
        success = this->evaluate_function(std::forward<FunctionLambda>(function), this->m_a, this->m_fa);
        OPTIMIST_ASSERT_WARNING(success,
          CMD "function evaluation failed at the lower bound.");
 
        this->m_b = this->m_upper_bound;
        success = this->evaluate_function(std::forward<FunctionLambda>(function), this->m_b, this->m_fb);
        OPTIMIST_ASSERT_WARNING(success,
          CMD "function evaluation failed at the upper bound.");
 
        // Check if the solution exists
        if (this->m_fa*this->m_fb > 0.0) {return false;}
        else {x_sol = this->find_root(std::forward<FunctionLambda>(function));}
 
        // Print bottom
        if (this->m_verbose) {this->bottom();}
 
        // Convergence data
        return this->m_converged;
 
        #undef CMD
      }

      template <typename FunctionLambda>
      Real find_root(FunctionLambda && function)
      {
        return static_cast<DerivedSolver *>(this)->find_root_impl(std::forward<FunctionLambda>(function));
      }
 
    }; // class Bracketing
 
  } // namespace RootFinder
 
} // namespace Optimist
 
#endif // OPTIMIST_ROOTFINDER_BRACKTING_HH