EllipticParaboloid.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_ELLIPTICPARABOLOID_HH
#define OPTIMIST_TESTSET_ELLIPTICPARABOLOID_HH
 
#include "Optimist/Function.hh"
 
namespace Optimist {
 
  namespace TestSet {

    template <typename Vector>
      requires TypeTrait<Vector>::IsEigen && (!TypeTrait<Vector>::IsFixed ||
                                              TypeTrait<Vector>::Dimension == 2)
    class EllipticParaboloid : public Function<Vector,
                                               typename Vector::Scalar,
                                               EllipticParaboloid<Vector>> {
     public:
      using VectorTrait = TypeTrait<Vector>;
      using Scalar      = typename Vector::Scalar;
      using typename Function<Vector, Scalar, EllipticParaboloid<Scalar>>::
          FirstDerivative;
      using typename Function<Vector, Scalar, EllipticParaboloid<Scalar>>::
          SecondDerivative;
 
      OPTIMIST_BASIC_CONSTANTS(Scalar)
 
     private:
      Scalar m_a{1.0}; 
      Scalar m_b{1.0}; 
 
     public:
      EllipticParaboloid() {
        this->m_solutions.emplace_back(0.0, 0.0);
        for (Scalar x{-100}; x < 100 + EPSILON; x += 100 / 25.0) {
          for (Scalar y{-100}; y < 100 + EPSILON; y += 100 / 25.0) {
            this->m_guesses.emplace_back(x, y);
          }
        }
      }

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

      bool evaluate_impl(const Vector &x, Scalar &out) const {
        out = this->m_a * x(0) * x(0) + this->m_b * x(1) * x(1);
        return std::isfinite(out);
      }

      bool first_derivative_impl(const Vector &x, FirstDerivative &out) const {
        out << 2.0 * this->m_a * x(0), 2.0 * this->m_b * x(1);
        return out.allFinite();
      }

      bool second_derivative_impl(const Vector & /*x*/,
                                  SecondDerivative &out) const {
        out << 2.0 * this->m_a, 0.0, 0.0, 2.0 * this->m_b;
        return out.allFinite();
      }
 
    };  // class EllipticParaboloid
 
  }  // namespace TestSet
 
}  // namespace Optimist
 
#endif  // OPTIMIST_TESTSET_ELLIPTICPARABOLOID_HH