Rosenbrock.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_TESTSET_ROSENBROCK_HH
#define OPTIMIST_TESTSET_ROSENBROCK_HH
 
#include "Optimist/TestSet.hh"
 
namespace Optimist
{
 
  namespace TestSet
  {

    template <typename Real, Integer N>
    class Rosenbrock : public Function<Real, N, N, Rosenbrock<Real, N>>
    {
      static_assert(N > 0 && N % 2 == 0, "please use an even number of dimensions");
 
    public:
      OPTIMIST_BASIC_CONSTANTS(Real)
 
      using typename Function<Real, N, N, Rosenbrock<Real, N>>::InputVector;
      using typename Function<Real, N, N, Rosenbrock<Real, N>>::OutputVector;
      using typename Function<Real, N, N, Rosenbrock<Real, N>>::Matrix;
      using typename Function<Real, N, N, Rosenbrock<Real, N>>::Tensor;

      Rosenbrock()
      {
        this->m_solutions.emplace_back(OutputVector::Ones());
        this->m_guesses.emplace_back(InputVector::Ones());
        for (Integer i{0}; i < N; i += 2) {
          this->m_guesses[0](i) = -1.2;
          this->m_guesses[0](i+1) = 1.0;
        }
      }

      std::string name_impl() const {return "Rosenbrock<" + std::to_string(N) + ">";}

      bool evaluate_impl(InputVector const & x, OutputVector & out) const
      {
        for (Integer i{0}; i < N; i += 2) {
          out(i)   = 10.0*(x(i+1) - x(i)*x(i));
          out(i+1) = 1.0 - x(i);
        }
        return out.allFinite();
      }

      bool first_derivative_impl(InputVector const & x, Matrix & out) const
      {
        out.setZero();
        for (Integer i{0}; i < N; i += 2) {
          out(i, i)   = -20.0*x(i);
          out(i, i+1) = 10.0;
          out(i+1, i) = -1.0;
        }
        return out.allFinite();
      }

      bool second_derivative_impl(InputVector const & /*x*/, Tensor & out) const
      {
        out.resize(this->output_dimension());
        for (size_t i{0}; i < out.size(); ++i) {
          out[i].setZero();
          for (Integer j{0}; j < N; j += 2) {
            out[i](j, j) = -20.0;
          }
        }
        return true;
      }
 
    }; // class Rosenbrock

    template <typename Real>
    using Rosenbrock2 = Rosenbrock<Real, 2>;

    template <typename Real>
    using Rosenbrock4 = Rosenbrock<Real, 4>;

    template <typename Real>
    using Rosenbrock6 = Rosenbrock<Real, 6>;

    template <typename Real>
    using Rosenbrock8 = Rosenbrock<Real, 8>;

    template <typename Real>
    using Rosenbrock10 = Rosenbrock<Real, 10>;
 
 
  } // namespace TestSet
 
} // namespace Optimist
 
#endif // OPTIMIST_TESTSET_ROSENBROCK_HH