Function.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_FUNCTION_HH
#define OPTIMIST_FUNCTION_HH
 
#include "Optimist.hh"
 
namespace Optimist {
 
  /*\
   |   _____                 _   _             ____
   |  |  ___|   _ _ __   ___| |_(_) ___  _ __ | __ )  __ _ ___  ___
   |  | |_ | | | | '_ \ / __| __| |/ _ \| '_ \|  _ \ / _` / __|/ _ \
   |  |  _|| |_| | | | | (__| |_| | (_) | | | | |_) | (_| \__ \  __/
   |  |_|   \__,_|_| |_|\___|\__|_|\___/|_| |_|____/ \__,_|___/\___|
   |
  \*/

  template <typename Input, typename Output, typename DerivedFunction>
    requires std::is_same<typename TypeTrait<Input>::Scalar,
                          typename TypeTrait<Output>::Scalar>::value &&
             (TypeTrait<Input>::IsScalar || TypeTrait<Input>::IsEigen) &&
             (TypeTrait<Output>::IsScalar || TypeTrait<Output>::IsEigen) &&
             (!TypeTrait<Input>::IsFixed || TypeTrait<Input>::Dimension > 0) &&
             (!TypeTrait<Output>::IsFixed ||
              TypeTrait<Output>::Dimension > 0) &&
             (!(TypeTrait<Input>::IsEigen && TypeTrait<Output>::IsEigen) ||
              (TypeTrait<Input>::IsFixed && TypeTrait<Output>::IsFixed) ||
              (TypeTrait<Input>::IsDynamic && TypeTrait<Output>::IsDynamic) ||
              (TypeTrait<Input>::IsSparse && TypeTrait<Output>::IsSparse))
  class FunctionBase {
   public:
    // Input and output types
    using InputTrait  = TypeTrait<Input>;
    using OutputTrait = TypeTrait<Output>;
    using Scalar      = typename InputTrait::Scalar;
 
    // Derivative types
    using FirstDerivative = std::conditional_t<
        InputTrait::IsEigen || OutputTrait::IsEigen,
        std::conditional_t<InputTrait::IsSparse || OutputTrait::IsSparse,
                           Eigen::SparseMatrix<Scalar>,
                           Eigen::Matrix<Scalar,
                                         OutputTrait::Dimension,
                                         InputTrait::Dimension>>,
        Scalar>;
    using SecondDerivative = std::conditional_t<
        InputTrait::IsEigen || OutputTrait::IsEigen,
        std::conditional_t<InputTrait::IsSparse || OutputTrait::IsSparse,
                           std::vector<Eigen::SparseMatrix<Scalar>>,
                           std::vector<Eigen::Matrix<Scalar,
                                                     OutputTrait::Dimension,
                                                     InputTrait::Dimension>>>,
        Scalar>;
 
    OPTIMIST_BASIC_CONSTANTS(Scalar)
 
   protected:
    std::vector<Input>
        m_solutions; 
    std::vector<Input>
        m_guesses;   
 
   public:
    FunctionBase() {}

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

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

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

    bool second_derivative(const Input &x, SecondDerivative &out) const {
      return static_cast<const DerivedFunction *>(this)->second_derivative_impl(
          x,
          out);
    }

    constexpr Integer input_dimension() const {
      return InputTrait::Dimension;
    }

    constexpr Integer output_dimension() const {
      return OutputTrait::Dimension;
    }

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

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

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

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

    bool is_solution(const Input &x,
                     const Scalar tol = FunctionBase::SQRT_EPSILON) const {
      for (const auto &s : this->m_solutions) {
        if constexpr (InputTrait::IsEigen) {
          if ((x - s).norm() < tol) {
            return true;
          }
        } else {
          if (std::abs(x - s) < tol) {
            return true;
          }
        }
      }
      return false;
    }
 
  };  // class FunctionBase
 
  /*\
   |   _____                 _   _
   |  |  ___|   _ _ __   ___| |_(_) ___  _ __
   |  | |_ | | | | '_ \ / __| __| |/ _ \| '_ \
   |  |  _|| |_| | | | | (__| |_| | (_) | | | |
   |  |_|   \__,_|_| |_|\___|\__|_|\___/|_| |_|
   |
  \*/

  template <typename Input, typename Output, typename DerivedFunction>
  class Function : public FunctionBase<Input, Output, DerivedFunction> {
   public:
    friend class FunctionBase<Input, Output, DerivedFunction>;
 
    // Derivative types
    using
        typename FunctionBase<Input, Output, DerivedFunction>::FirstDerivative;
    using
        typename FunctionBase<Input, Output, DerivedFunction>::SecondDerivative;

    Function() {}

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

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

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

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

  template <typename T, typename DerivedFunction>
    requires(TypeTrait<T>::IsScalar || TypeTrait<T>::IsEigen) &&
            (!TypeTrait<T>::IsFixed || TypeTrait<T>::Dimension > 0)
  class Function<T, T, DerivedFunction>
      : public FunctionBase<T, T, DerivedFunction> {
   public:
    friend class FunctionBase<T, T, DerivedFunction>;
 
    // Input and output types
    using Scalar = typename TypeTrait<T>::Scalar;
    using Input  = T;
    using Output = T;
 
    // Derivative types
    using typename FunctionBase<T, T, DerivedFunction>::FirstDerivative;
    using typename FunctionBase<T, T, DerivedFunction>::SecondDerivative;
    Function<T, T, DerivedFunction>() {}
    constexpr std::string name() const {
      return static_cast<const DerivedFunction *>(this)->name_impl();
    }

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

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

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