Function.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_FUNCTION_HH
#define OPTIMIST_FUNCTION_HH
 
#include "Optimist.hh"
 
namespace Optimist
{

  template <typename Real, Integer FunInDim, Integer FunOutDim, typename DerivedFunction>
  class Function
  {
  public:
    // Fancy static assertios (just for fun, don't take it too seriously)
    static_assert(FunInDim > static_cast<Integer>(0) && FunOutDim > static_cast<Integer>(0),
      "Negative-dimensional function? Are you serious?");
 
    OPTIMIST_BASIC_CONSTANTS(Real) 
 
    // I/O types
    using InputType  = typename std::conditional_t<FunInDim == 1,  Real, Eigen::Vector<Real, FunInDim>>;  
    using OutputType = typename std::conditional_t<FunOutDim == 1, Real, Eigen::Vector<Real, FunOutDim>>; 
 
    // Derivative types
    using FirstDerivativeType  = std::conditional_t<FunInDim == 1 && FunOutDim == 1, Real, Eigen::Matrix<Real, FunOutDim, FunInDim>>; 
    using SecondDerivativeType = std::conditional_t<FunInDim == 1 && FunOutDim == 1, Real,
      std::conditional_t<FunInDim == 1 || FunOutDim == 1, Eigen::Matrix<Real, FunInDim, FunInDim>,
      std::vector<Eigen::Matrix<Real, FunInDim, FunInDim>>>>;  
 
  protected:
    std::vector<InputType> m_solutions; 
    std::vector<InputType> m_guesses;   
 
  public:
    Function() {}

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

    void evaluate(const InputType & x, OutputType & out) const
    {
      static_cast<const DerivedFunction *>(this)->evaluate_impl(x, out);
    }

    void first_derivative(const InputType & x, FirstDerivativeType & out) const
    {
      static_cast<const DerivedFunction *>(this)->first_derivative_impl(x, out);
    }

    void second_derivative(const InputType & x, SecondDerivativeType & out) const
    {
      static_cast<const DerivedFunction *>(this)->second_derivative_impl(x, out);
    }

    constexpr Integer input_dimension() const {return FunInDim;}

    constexpr Integer output_dimension() const {return FunOutDim;}

    const std::vector<InputType> & solutions() const {return this->m_solutions;}

    const std::vector<InputType> & guesses() const {return this->m_guesses;}

    const InputType & solution(const Integer i) const {return this->m_solutions.at(i);}

    const InputType & guess(const Integer i) const {return this->m_guesses.at(i);}

    bool is_solution(const InputType & x, const Real tol = EPSILON_LOW) const
    {
      for (const auto & s : this->m_solutions) {
        if constexpr (FunInDim == 1) {
          if (std::abs(x - s) < tol) {return true;}
        } else if constexpr (FunInDim > 1) {
          if((x - s).norm() < tol) {return true;}
        } else {
          OPTIMIST_ERROR("Optimist::Function::is_solution(...): invalid input dimension.");
          return false;
        }
      }
      return false;
    }
 
  }; // class Function
 
} // namespace Optimist
 
#endif // OPTIMIST_FUNCTION_HH