Brown.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_TESTSET_BROWN_HH
#define OPTIMIST_TESTSET_BROWN_HH
 
#include "Optimist/Function.hh"
 
namespace Optimist {
 
  namespace TestSet {

    template <typename Input, typename Output>
      requires TypeTrait<Input>::IsEigen && TypeTrait<Output>::IsEigen &&
               (!TypeTrait<Input>::IsFixed ||
                TypeTrait<Input>::Dimension == 2) &&
               (!TypeTrait<Output>::IsFixed ||
                TypeTrait<Output>::Dimension == 3)
    class Brown : public Function<Input, Output, Brown<Input, Output>> {
     private:
      using Scalar = typename Input::Scalar;
      using typename Function<Input, Output, Brown<Input, Output>>::
          FirstDerivative;
      using typename Function<Input, Output, Brown<Input, Output>>::
          SecondDerivative;
 
      Scalar m_a{
        1.0e-6}; 
 
     public:
      OPTIMIST_BASIC_CONSTANTS(Scalar)
 
      
      Brown() {
        this->m_solutions.emplace_back(this->m_a, 2.0 * this->m_a);
        this->m_guesses.emplace_back(1.0, 1.0);
      }

      constexpr std::string name_impl() const {
        return "Brown";
      }

      bool evaluate_impl(const Input &x, Output &out) const {
        out << x(0) - this->m_a, x(1) - 2.0 * this->m_a, x(0) * x(1) - 2.0;
        return out.allFinite();
      }

      bool first_derivative_impl(const Input &x, FirstDerivative &out) const {
        out << 1.0, 0.0, x(1), 0.0, 1.0, x(0);
        return out.allFinite();
      }

      bool second_derivative_impl(const Input & /*x*/,
                                  SecondDerivative &out) const {
        out.resize(this->output_dimension());
        out[0].setZero();
        out[1].setZero();
        out[2] << 0.0, 1.0, 1.0, 0.0;
        return out[0].allFinite() && out[1].allFinite() && out[2].allFinite();
      }
 
    };  // class Brown
 
  }  // namespace TestSet
 
}  // namespace Optimist
 
#endif  // OPTIMIST_TESTSET_BROWN_HH