VectorFunction.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_HH
#define OPTIMIST_VECTOR_FUNCTION_HH
 
#include "Optimist/Function.hh"
 
namespace Optimist
{

  template <typename Real, Integer N, Integer M, typename DerivedFunction>
  class VectorFunction : public Function<Real, N, M, DerivedFunction>
  {
  public:
    friend Function<Real, N, M, VectorFunction<Real, N, M, DerivedFunction>>;
 
    // Fancy static assertions (just for fun, don't take it too seriously)
    static_assert(N != static_cast<Integer>(0) && M != static_cast<Integer>(0),
      "Are you sure you want to a zero-dimensional system of equations?");
    static_assert(N != static_cast<Integer>(1) && M != static_cast<Integer>(1),
      "C'mon, let's not kid ourselves. Use a scalar function...");
    static_assert(M != static_cast<Integer>(1),
      "Good try, but you're looking for an objective function, not a vector-valued function.");
 
    // I/O types
    using InputVector = typename Function<Real, N, M, DerivedFunction>::InputType; 
    using OutputVector = typename Function<Real, N, M, DerivedFunction>::OutputType; 
 
    // Derivative types
    using Matrix = typename Function<Real, N, M, DerivedFunction>::FirstDerivativeType;  
    using Tensor = typename Function<Real, N, M, DerivedFunction>::SecondDerivativeType; 

    VectorFunction() {}

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

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

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

    void hessian(const InputVector & x, Tensor & out) const
    {
      static_cast<const DerivedFunction *>(this)->second_derivative_impl(x, out);
    }
 
  }; // class VectorFunction
 
} // namespace Optimist
 
#endif // OPTIMIST_VECTOR_FUNCTION_HH