Implicit.hh

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *\
 * Copyright (c) 2025, Davide Stocco and Enrico Bertolazzi.                                      *
 *                                                                                               *
 * The Sandals project is distributed under the BSD 2-Clause License.                            *
 *                                                                                               *
 * Davide Stocco                                                               Enrico Bertolazzi *
 * University of Trento                                                     University of Trento *
 * e-mail: davide.stocco@unitn.it                             e-mail: enrico.bertolazzi@unitn.it *
\* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
 
#pragma once
 
#ifndef SANDALS_IMPLICIT_SYSTEM_HH
#define SANDALS_IMPLICIT_SYSTEM_HH
 
#include <Sandals.hh>
 
namespace Sandals
{
 
  /*\
   |   ___                 _ _      _ _
   |  |_ _|_ __ ___  _ __ | (_) ___(_) |_
   |   | || '_ ` _ \| '_ \| | |/ __| | __|
   |   | || | | | | | |_) | | | (__| | |_
   |  |___|_| |_| |_| .__/|_|_|\___|_|\__|
   |                |_|
  \*/

  template <typename Real, Integer N, Integer M = 0>
  class Implicit
  {
  public:
    using Type = enum class Type : Integer {IMPLICIT = 0, EXPLICIT = 1, SEMIEXPLICIT = 1}; 
    using Pointer = std::shared_ptr<Implicit<Real, N, M>>; 
    using VectorF = Eigen::Vector<Real, N>; 
    using MatrixJF = Eigen::Matrix<Real, N, N>; 
    using VectorH = Eigen::Vector<Real, M>; 
    using MatrixJH = Eigen::Matrix<Real, M, N>; 
 
  private:
    Type        m_type{Type::IMPLICIT}; 
    std::string m_name;                 
 
  protected:
    Implicit(Type t_type, std::string t_name) : m_type(t_type), m_name(t_name) {}
 
  public:
    Implicit() : m_type(Type::IMPLICIT), m_name("(missing name)") {}

    Implicit(std::string t_name) : m_type(Type::IMPLICIT), m_name(t_name) {}

    virtual ~Implicit() {}

    Type type() const {return this->m_type;}

    bool is_implicit() const {return this->m_type == Type::IMPLICIT;}

    bool is_explicit() const {return this->m_type == Type::EXPLICIT;}

    bool is_semiexplicit() const {return this->m_type == Type::SEMIEXPLICIT;}

    std::string & name() {return this->m_name;}

    std::string const & name() const {return this->m_name;}

    Integer equations_number() const {return N;}

    Integer invariants_number() const {return M;}

    virtual VectorF F(VectorF const & x, VectorF const & x_dot, Real const t) const = 0;

    virtual MatrixJF JF_x(VectorF const & x, VectorF const & x_dot, Real const t) const = 0;

    virtual MatrixJF JF_x_dot(VectorF const & x, VectorF const & x_dot, Real const t) const = 0;

    virtual VectorH h(VectorF const & x, Real const t) const = 0;

    virtual MatrixJH Jh_x(VectorF const & x, Real const t) const = 0;

    virtual bool in_domain(VectorF const & x, Real const t) const = 0;

    VectorF F_reverse(VectorF const & x, VectorF const & x_dot, Real const t) const
    {
      return -this->F(x, -x_dot, -t);
    }

    MatrixJF JF_x_reverse(VectorF const & x, VectorF const & x_dot, Real const t) const
    {
      return -this->JF_x(x, -x_dot, -t);
    }

    MatrixJF JF_x_dot_reverse(VectorF const & x, VectorF const & x_dot, Real const t) const
    {
      return this->JF_x_dot(x, -x_dot, -t);
    }
 
  }; // class Implicit
 
  /*\
   |   ___                 _ _      _ _ __        __
   |  |_ _|_ __ ___  _ __ | (_) ___(_) |\ \      / / __ __ _ _ __  _ __   ___ _ __
   |   | || '_ ` _ \| '_ \| | |/ __| | _ \ \ /\ / / '__/ _` | '_ \| '_ \ / _ \ '__|
   |   | || | | | | | |_) | | | (__| | |_ \ V  V /| | | (_| | |_) | |_) |  __/ |
   |  |___|_| |_| |_| .__/|_|_|\___|_|\__| \_/\_/ |_|  \__,_| .__/| .__/ \___|_|
   |                |_|                                       |_|   |_|
  \*/

  template <typename Real, Integer N, Integer M = 0>
  class ImplicitWrapper : public Implicit<Real, N, M>
  {
  public:
    using Pointer = std::shared_ptr<ImplicitWrapper<Real, N, M>>; 
    using typename Implicit<Real, N, M>::VectorF; 
    using typename Implicit<Real, N, M>::MatrixJF; 
    using typename Implicit<Real, N, M>::VectorH; 
    using typename Implicit<Real, N, M>::MatrixJH; 
    using FunctionF = std::function<VectorF(VectorF const &, VectorF const &, Real const)>; 
    using FunctionJF = std::function<MatrixJF(VectorF const &, VectorF const &, Real const)>; 
    using FunctionH = std::function<VectorH(VectorF const &, Real const)>; 
    using FunctionJH = std::function<MatrixJH(VectorF const &, Real const)>; 
    using FunctionID = std::function<bool(VectorF const &, Real const)>; 
 
    inline static const FunctionH DefaultH = [](VectorF const &, Real const) {return VectorH::Zero();}; 
    inline static const FunctionJH DefaultJH = [](VectorF const &, Real const) {return MatrixJH::Zero();}; 
    inline static const FunctionID DefaultID = [](VectorF const &, Real const) {return true;}; 
 
  private:
    FunctionF m_F{nullptr}; 
    FunctionJF m_JF_x{nullptr}; 
    FunctionJF m_JF_x_dot{nullptr}; 
    FunctionH m_h{nullptr}; 
    FunctionJH m_Jh_x{nullptr}; 
    FunctionID m_in_domain{nullptr}; 
 
  public:
    ImplicitWrapper(FunctionF t_F, FunctionJF t_JF_x, FunctionJF t_JF_x_dot, FunctionH t_h = DefaultH,
      FunctionJH t_Jh_x = DefaultJH, FunctionID t_in_domain = DefaultID) : Implicit<Real, N, M>(), m_F(t_F), m_JF_x(t_JF_x),
      m_JF_x_dot(t_JF_x_dot), m_h(t_h), m_Jh_x(t_Jh_x), m_in_domain(t_in_domain)
    {}

    ImplicitWrapper(std::string t_name, FunctionF t_F, FunctionJF t_JF_x, FunctionJF t_JF_x_dot,
      FunctionH t_h = DefaultH, FunctionJH t_Jh_x = DefaultJH, FunctionID t_in_domain = DefaultID)
    : Implicit<Real, N, M>(t_name), m_F(t_F), m_JF_x(t_JF_x), m_JF_x_dot(t_JF_x_dot), m_h(t_h),
      m_Jh_x(t_Jh_x), m_in_domain(t_in_domain)
    {}

    ~ImplicitWrapper() {}

    FunctionF & F() {return this->m_F;}

    FunctionJF & JF_x() {return this->m_JF_x;}

    FunctionJF & JF_x_dot() {return this->m_JF_x_dot;}

    FunctionH & h() {return this->m_h;}

    FunctionJH & Jh_x() {return this->m_Jh_x;}

    FunctionID & in_domain() {return this->m_in_domain;}

    VectorF F(VectorF const & x, VectorF const & x_dot, Real const t) const override
    {
      return this->m_F(x, x_dot, t);
    }

    MatrixJF JF_x(VectorF const & x, VectorF const & x_dot, Real const t) const override
    {
      return this->m_JF_x(x, x_dot, t);
    }

    MatrixJF JF_x_dot(VectorF const & x, VectorF const & x_dot, Real const t) const override
    {
      return this->m_JF_x_dot(x, x_dot, t);
    }

    VectorH h(VectorF const & x, Real const t) const override
    {
      return this->m_h(x, t);
    }

    MatrixJH Jh_x(VectorF const & x, Real const t) const override
    {
      return this->m_Jh_x(x, t);
    }

    bool in_domain(VectorF const & x, Real const t) const override
    {
      return this->m_in_domain(x, t);
    }
 
  }; // class ImplicitWrapper
 
} // namespace Sandals
 
#endif // SANDALS_IMPLICIT_SYSTEM_HH