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

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

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

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

    bool second_derivative(const InputType & x, SecondDerivativeType & out) const
    {
      return 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(Integer const i) const {return this->m_solutions.at(i);}

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

    bool is_solution(const InputType & x, Real const tol = EPSILON_LOW) const
    {
      for (const auto & s : this->m_solutions) {
        if constexpr (ForceEigen || FunInDim > 1) {
          if((x - s).norm() < tol) {return true;}
        } else {
          if (std::abs(x - s) < tol) {return true;}
        }
      }
      return false;
    }
 
  }; // class FunctionBase
 
  /*\
   |   _____                 _   _
   |  |  ___|   _ _ __   ___| |_(_) ___  _ __
   |  | |_ | | | | '_ \ / __| __| |/ _ \| '_ \
   |  |  _|| |_| | | | | (__| |_| | (_) | | | |
   |  |_|   \__,_|_| |_|\___|\__|_|\___/|_| |_|
   |
  \*/

  template <typename Real, Integer N, Integer M, typename DerivedFunction, bool ForceEigen = false>
  class Function : public FunctionBase<Real, N, M, DerivedFunction, ForceEigen>
  {
  public:
    friend class FunctionBase<Real, N, M, Function<Real, N, M, DerivedFunction, ForceEigen>>;
 
    // Fancy static assertions (just for fun, don't take it too seriously)
    static_assert(N != 0 && M != 0,
      "Are you sure you want to a zero-dimensional system of equations?");
 
    // I/O types
    using InputVector = typename FunctionBase<Real, N, M, DerivedFunction, ForceEigen>::InputType;
    using OutputVector = typename FunctionBase<Real, N, M, DerivedFunction, ForceEigen>::OutputType;
 
    // Derivative types
    using Matrix = typename FunctionBase<Real, N, M, DerivedFunction, ForceEigen>::FirstDerivativeType;
    using Tensor = typename FunctionBase<Real, N, M, DerivedFunction, ForceEigen>::SecondDerivativeType;

    Function() {}

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

    bool evaluate(const InputVector & x, OutputVector & out) const
    {
      return static_cast<const DerivedFunction *>(this)->evaluate_impl(x, out);
    }

    bool jacobian(const InputVector & x, Matrix & out) const
    {
      return static_cast<const DerivedFunction *>(this)->first_derivative_impl(x, out);
    }

    bool hessian(const InputVector & x, Tensor & out) const
    {
      return static_cast<const DerivedFunction *>(this)->second_derivative_impl(x, out);
    }
 
  }; // class Function
 
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  template <typename Real, Integer N, typename DerivedFunction>
  class Function<Real, N, 1, DerivedFunction> : public FunctionBase<Real, N, 1, DerivedFunction>
  {
  public:
    friend class FunctionBase<Real, N, 1, Function<Real, N, 1, DerivedFunction>>;
 
    // Fancy static assertions (just for fun, don't take it too seriously)
    static_assert(N != 0,
      "Are you sure you want to a zero-dimensional system of equations?");
 
    // I/O types
    using Vector = typename FunctionBase<Real, N, 1, DerivedFunction>::InputType;
 
    // Derivative types
    using RowVector = typename FunctionBase<Real, N, 1, DerivedFunction>::FirstDerivativeType;
    using Matrix    = typename FunctionBase<Real, N, 1, DerivedFunction>::SecondDerivativeType;

    Function<Real, N, 1, DerivedFunction>() {}

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

    bool evaluate(Vector const & x, Vector & out) const
    {
      return static_cast<const DerivedFunction *>(this)->evaluate_impl(x, out);
    }

    bool gradient(Vector const & x, RowVector & out) const
    {
      return static_cast<const DerivedFunction *>(this)->first_derivative_impl(x, out);
    }

    bool hessian(Vector const & x, Matrix & out) const
    {
      return static_cast<const DerivedFunction *>(this)->second_derivative_impl(x, out);
    }
 
  }; // class Function
 
  // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

  template <typename Real, typename DerivedFunction>
  class Function<Real, 1, 1, DerivedFunction> : public FunctionBase<Real, 1, 1, DerivedFunction>
  {
  public:
    friend class FunctionBase<Real, 1, 1, Function<Real, 1, 1, DerivedFunction>>;

    Function<Real, 1, 1, DerivedFunction>() {}

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

    bool evaluate(Real x, Real & out) const
    {
      return static_cast<const DerivedFunction *>(this)->evaluate_impl(x, out);
    }

    bool first_derivative(Real x, Real & out) const
    {
      return static_cast<const DerivedFunction *>(this)->first_derivative_impl(x, out);
    }

    bool second_derivative(Real x, Real & out) const
    {
      return static_cast<const DerivedFunction *>(this)->second_derivative_impl(x, out);
    }
 
  }; // class Function
 
} // namespace Optimist
 
#endif // OPTIMIST_FUNCTION_HH