RootFinder.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco and Enrico Bertolazzi.                  *
 *                                                                           *
 * The Optimist project is distributed under the BSD 2-Clause License.       *
 *                                                                           *
 * Davide Stocco                                           Enrico Bertolazzi *
 * University of Trento                                 University of Trento *
 * davide.stocco@unitn.it                         enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef OPTIMIST_ROOTFINDER_HH
#define OPTIMIST_ROOTFINDER_HH
 
#include "Optimist/SolverBase.hh"
 
namespace Optimist {

  namespace RootFinder {
 
    /*\
     |   ____             _   _____ _           _
     |  |  _ \ ___   ___ | |_|  ___(_)_ __   __| | ___ _ __
     |  | |_) / _ \ / _ \| __| |_  | | '_ \ / _` |/ _ \ '__|
     |  |  _ < (_) | (_) | |_|  _| | | | | | (_| |  __/ |
     |  |_| \_\___/ \___/ \__|_|   |_|_| |_|\__,_|\___|_|
     |
    \*/

    template <typename T, typename DerivedSolver>
      requires(TypeTrait<T>::IsScalar || TypeTrait<T>::IsEigen) &&
              (!TypeTrait<T>::IsFixed || TypeTrait<T>::Dimension > 0)
    class RootFinder : public SolverBase<T, T, DerivedSolver> {
     public:
      friend class SolverBase<T, T, DerivedSolver>;
 
      static constexpr bool IsRootFinder{true};
      static constexpr bool IsOptimizer{false};
 
      // Input and output types
      using Scalar = typename TypeTrait<T>::Scalar;
      using Input  = T;
      using Output = T;
 
      // Derivative types
      using typename SolverBase<T, T, DerivedSolver>::FirstDerivative;
      using typename SolverBase<T, T, DerivedSolver>::SecondDerivative;
 
      OPTIMIST_BASIC_CONSTANTS(Scalar)
 
      
      RootFinder() {}

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

      Integer jacobian_evaluations() const {
        return this->first_derivative_evaluations();
      }

      Integer max_jacobian_evaluations() const {
        return this->max_first_derivative_evaluations();
      }

      void max_jacobian_evaluations(const Integer t_jacobian_evaluations) {
        this->max_first_derivative_evaluations(t_jacobian_evaluations);
      }

      Integer hessian_evaluations() const {
        return this->first_derivative_evaluations();
      }

      Integer max_hessian_evaluations() const {
        return this->max_first_derivative_evaluations();
      }

      void max_hessian_evaluations(const Integer t_hessian_evaluations) {
        this->max_first_derivative_evaluations(t_hessian_evaluations);
      }
 
     protected:
      template <typename JacobianLambda>
      bool evaluate_jacobian(JacobianLambda &&jacobian,
                             const Input &x,
                             FirstDerivative &out) {
        return this->evaluate_first_derivative(
            std::forward<JacobianLambda>(jacobian),
            x,
            out);
      }

      template <typename HessianLambda>
      bool evaluate_hessian(HessianLambda &&hessian,
                            const Input &x,
                            SecondDerivative &out) {
        return this->evaluate_second_derivative(
            std::forward<HessianLambda>(hessian),
            x,
            out);
      }
 
     public:
      template <typename FunctionLambda>
      bool solve(FunctionLambda &&function, const Input &x_ini, Output &x_sol) {
#define CMD "Optimist::RootFinder::solve(...): "
 
        static_assert(DerivedSolver::RequiresFunction,
                      CMD "the solver requires a function.");
        return static_cast<DerivedSolver *>(this)->solve_impl(
            std::forward<FunctionLambda>(function),
            x_ini,
            x_sol);
 
#undef CMD
      }

      template <typename FunctionLambda, typename JacobianLambda>
      bool solve(FunctionLambda &&function,
                 JacobianLambda &&jacobian,
                 const Input &x_ini,
                 Output &x_sol) {
#define CMD "Optimist::RootFinder::solve(...): "
 
        static_assert(DerivedSolver::RequiresFunction,
                      CMD "the solver requires a function.");
        static_assert(DerivedSolver::RequiresFirstDerivative,
                      CMD "the solver requires the first derivative.");
        return static_cast<DerivedSolver *>(this)->solve_impl(
            std::forward<FunctionLambda>(function),
            std::forward<JacobianLambda>(jacobian),
            x_ini,
            x_sol);
 
#undef CMD
      }

      template <typename FunctionLambda,
                typename JacobianLambda,
                typename HessianLambda>
      bool solve(FunctionLambda &&function,
                 JacobianLambda &&jacobian,
                 HessianLambda &&hessian,
                 const Input &x_ini,
                 Output &x_sol) {
#define CMD "Optimist::RootFinder::solve(...): "
 
        static_assert(DerivedSolver::RequiresFunction,
                      CMD "the solver requires the function.");
        static_assert(DerivedSolver::RequiresFirstDerivative,
                      CMD "the solver requires the first derivative.");
        static_assert(DerivedSolver::RequiresSecondDerivative,
                      CMD "the solver requires the second derivative.");
        return static_cast<DerivedSolver *>(this)->solve_impl(
            std::forward<FunctionLambda>(function),
            std::forward<JacobianLambda>(jacobian),
            std::forward<HessianLambda>(hessian),
            x_ini,
            x_sol);
 
#undef CMD
      }
 
    };  // class RootFinder
 
  }  // namespace RootFinder
 
}  // namespace Optimist
 
#endif  // OPTIMIST_ROOTFINDER_HH