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

    template <typename Real>
    class Brown : public VectorFunction<Real, 2, 3, Brown<Real>>
    {
    private:
      Real m_a{1.0e-6}; 
 
    public:
      OPTIMIST_BASIC_CONSTANTS(Real) 
 
      using InputVector  = typename VectorFunction<Real, 2, 3, Brown<Real>>::InputVector;
      using OutputVector = typename VectorFunction<Real, 2, 3, Brown<Real>>::OutputVector;
      using Matrix       = typename VectorFunction<Real, 2, 3, Brown<Real>>::Matrix;
      using Tensor       = typename VectorFunction<Real, 2, 3, Brown<Real>>::Tensor;

      Brown()
      {
        this->m_solutions.emplace_back(this->m_a, 2.0*this->m_a);
        this->m_guesses.emplace_back(1.0, 1.0);
      }

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

      void evaluate_impl(const InputVector & x, OutputVector & out) const
      {
        out << x(0) - this->m_a,
               x(1) - 2.0*this->m_a,
               x(0)*x(1) - 2.0;
      }

      void first_derivative_impl(const InputVector & x, Matrix & out) const
      {
        out << 1.0, 0.0, x(1),
               0.0, 1.0, x(0);
      }

      void second_derivative_impl(const InputVector & /*x*/, Tensor & out) const
      {
        out.resize(this->output_dimension());
        out[0].setZero();
        out[1].setZero();
        out[2] << 0.0, 1.0,
                  1.0, 0.0;
      }
 
    }; // class Brown
 
  } // namespace TestSet
 
} // namespace Optimist
 
#endif // OPTIMIST_VECTOR_FUNCTION_BROWN_HH