Optimizer.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_OPTIMIZER_HH
#define OPTIMIST_OPTIMIZER_HH
 
#include "Solver.hh"
 
namespace Optimist
{

  namespace Optimizer
  {
 
    /*\
     |    ___        _   _           _
     |   / _ \ _ __ | |_(_)_ __ ___ (_)_______ _ __
     |  | | | | '_ \| __| | '_ ` _ \| |_  / _ \ '__|
     |  | |_| | |_) | |_| | | | | | | |/ /  __/ |
     |   \___/| .__/ \__|_|_| |_| |_|_/___\___|_|
     |        |_|
    \*/

    template <typename Real, Integer N, typename DerivedSolver>
    class Optimizer : public Solver<Real, N, 1, DerivedSolver>
    {
    public:
      // Fancy static assertions (just for fun, don't take it too seriously)
      static_assert(N != static_cast<Integer>(0),
        "Have you ever heard of a zero-dimensional optimization problem?");
      static_assert(N != static_cast<Integer>(1),
        "Good try, but you should use a scalar solver for a one-dimensional optimization problem.");
 
      friend Solver<Real, N, 1, Optimizer<Real, N, DerivedSolver>>;
 
      static constexpr bool is_rootfinder{false};
      static constexpr bool is_optimizer{true};
 
      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) 
 
      // I/O types
      using Vector = typename Solver<Real, N, 1, DerivedSolver>::InputType; 
 
      // Derivative types
      using RowVector = typename Solver<Real, N, 1, DerivedSolver>::FirstDerivativeType;  
      using Matrix    = typename Solver<Real, N, 1, DerivedSolver>::SecondDerivativeType; 
 
      // Function types
      using FunctionWrapper = typename Solver<Real, N, 1, DerivedSolver>::FunctionWrapper;
      using GradientWrapper = typename Solver<Real, N, 1, DerivedSolver>::FirstDerivativeWrapper;
      using HessianWrapper  = typename Solver<Real, N, 1, DerivedSolver>::SecondDerivativeWrapper;

      Optimizer() {}

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

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

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

      void max_gradient_evaluations(Integer t_gradient_evaluations)
      {
        this->max_first_derivative_evaluations(t_gradient_evaluations);
      }

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

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

      void max_hessian_evaluations(Integer t_hessian_evaluations)
      {
        this->max_second_derivative_evaluations(t_hessian_evaluations);
      }
 
    protected:
      void evaluate_gradient(GradientWrapper gradient, const Vector & x, Matrix & out)
      {
        this->evaluate_first_derivative_impl(gradient, x, out);
      }

      void evaluate_hessian(HessianWrapper hessian, const Vector & x, Matrix & out)
      {
        this->evaluate_second_derivative_impl(hessian, x, out);
      }

      bool solve(FunctionWrapper function, Vector const & x_ini, Vector & x_sol)
      {
        #define CMD "Optimist::Optimizer::solve(...): "
 
        static_assert(DerivedSolver::requires_function,
          CMD "the solver requires the function.");
        return static_cast<DerivedSolver *>(this)->solve_impl(function, x_ini, x_sol);
 
        #undef CMD
      }

      bool solve(FunctionWrapper function, GradientWrapper gradient, Vector const & x_ini, Vector & x_sol)
      {
        #define CMD "Optimist::Optimizer::solve(...): "
 
        static_assert(DerivedSolver::requires_function,
          CMD "the solver requires the function.");
        static_assert(DerivedSolver::requires_first_derivative,
          CMD "the solver requires the first derivative.");
        return static_cast<DerivedSolver *>(this)->solve_impl(function, gradient, x_ini, x_sol);
 
        #undef CMD
      }

      bool solve(FunctionWrapper function, GradientWrapper gradient, HessianWrapper hessian, Vector
        const & x_ini, Vector & x_sol)
      {
        #define CMD "Optimist::Optimizer::solve(...): "
 
        static_assert(DerivedSolver::requires_function,
          CMD "the solver requires the function.");
        static_assert(DerivedSolver::requires_first_derivative,
          CMD "the solver requires the first derivative.");
        static_assert(DerivedSolver::requires_second_derivative,
          CMD "the solver requires the second derivative.");
        return static_cast<DerivedSolver *>(this)->solve_impl(function, gradient, hessian, x_ini, x_sol);
 
        #undef CMD
      }
 
    }; // class Optimizer
 
  } // namespace Optimizer
 
} // namespace Optimist
 
#endif // OPTIMIST_OPTIMIZER_HH