Solution.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_SOLUTION_HH
#define SANDALS_SOLUTION_HH
 
#include <Sandals.hh>
 
namespace Sandals {
 
  /*\
   |   ____        _       _   _
   |  / ___|  ___ | |_   _| |_(_) ___  _ __
   |  \___ \ / _ \| | | | | __| |/ _ \| '_ \
   |   ___) | (_) | | |_| | |_| | (_) | | | |
   |  |____/ \___/|_|\__,_|\__|_|\___/|_| |_|
   |
  \*/

  template <typename Real, Integer N, Integer M = 0>
  struct Solution
  {
    using Vector  = Eigen::Vector<Real, Eigen::Dynamic>; 
    using MatrixN = Eigen::Matrix<Real, N, Eigen::Dynamic, Eigen::RowMajor>; 
    using MatrixM = Eigen::Matrix<Real, M, Eigen::Dynamic, Eigen::RowMajor>; 
 
    Vector  t; 
    MatrixN x; 
    MatrixM h; 

    Solution() : t(0), x(Vector::Zero(N, 0)), h(Vector::Zero(M, 0)) {}

    Solution(Integer const size)
      : t(size), x(Vector::Zero(N, size)), h(Vector::Zero(M, size)) {}

    void resize(Integer const size) {
      this->t.resize(size);
      this->x.resize(Eigen::NoChange, size);
      this->h.resize(Eigen::NoChange, size);
    }

    void conservative_resize(Integer const size) {
      this->t.conservativeResize(size);
      this->x.conservativeResize(Eigen::NoChange, size);
      this->h.conservativeResize(Eigen::NoChange, size);
    }

    void clear()
    {
      this->t.resize(0);
      this->x.resize(Eigen::NoChange, 0);
      this->h.resize(Eigen::NoChange, 0);
    }

    bool is_empty() const
    {
      return this->t.size() == 0 && this->x.cols()== 0 && this->h.cols() == 0;
    }

    Integer size() const {return this->t.size();}

    std::vector<Real> std_t() const
    {
      return std::vector<Real>(this->t.data(), this->t.data() + this->t.size());
    }

    Vector eig_t() const {return this->t;}

    std::vector<Real> std_x(Integer i) const
    {
      Vector tmp(this->x.row(i));
      return std::vector<Real>(tmp.data(), tmp.data() + tmp.size());
    }

    std::map<Integer, std::vector<Real>> std_x() const
    {
      std::map<Integer, std::vector<Real>> x_map;
      for (Integer i{0}; i < N; ++i) {x_map[i] = this->std_x(i);}
      return x_map;
    }

    std::map<Integer, Vector> eig_x() const
    {
      std::map<Integer, Vector> x_map;
      for (Integer i{0}; i < N; ++i) {x_map[i] = this->x.row(i);}
      return x_map;
    }

    std::map<std::string, std::vector<Real>> std_x(std::vector<std::string> const & names) const
    {
      std::map<std::string, std::vector<Real>> x_map;
      for (Integer i{0}; i < N; ++i) {x_map[names[i]] = this->std_x(i);}
      return x_map;
    }

    std::map<std::string, Vector> eig_x(std::vector<std::string> const & names) const
    {
      std::map<std::string, Vector> x_map;
      for (Integer i{0}; i < N; ++i) {x_map[names[i]] = this->x.row(i);}
      return x_map;
    }

    std::vector<Real> std_h(Integer const i) const
    {
      Vector tmp(this->h.row(i));
      return std::vector<Real>(tmp.data(), tmp.data() + tmp.size());
    }

    std::map<Integer, std::vector<Real>> std_h() const
    {
      std::map<Integer, std::vector<Real>> h_map;
      for (Integer i{0}; i < M; ++i) {h_map[i] = this->std_h(i);}
      return h_map;
    }

    std::map<Integer, Vector> eig_h() const
    {
      std::map<Integer, Vector> h_map;
      for (Integer i{0}; i < M; ++i) {h_map[i] = this->h.row(i);}
      return h_map;
    }

    std::map<std::string, std::vector<Real>> std_h(std::vector<std::string> const & names) const
    {
      std::map<std::string, std::vector<Real>> h_map;
      for (Integer i{0}; i < M; ++i) {h_map[names[i]] = this->std_h(i);}
      return h_map;
    }

    std::map<std::string, Vector> eig_h(std::vector<std::string> const & names) const
    {
      std::map<std::string, Vector> h_map;
      for (Integer i{0}; i < M; ++i) {h_map[names[i]] = this->h.row(i);}
      return h_map;
    }
  };
 
} // namespace Sandals
 
#endif // SANDALS_SOLUTION_HH