LinearizedControlProblem.h

Go to the documentation of this file.

/* Copyright 2017-2020 CNRS-AIST JRL and CNRS-UM LIRMM */
 
#pragma once
 
#include <tvm/defs.h>
 
#include <tvm/ControlProblem.h>
#include <tvm/hint/Substitution.h>
#include <tvm/hint/internal/Substitutions.h>
 
#include <optional>
 
namespace tvm
{
class TVM_DLLAPI LinearConstraintWithRequirements
{
public:
  LinearConstraintPtr constraint;
  SolvingRequirementsPtr requirements;
  bool bound;
};
 
class TVM_DLLAPI LinearizedControlProblem : public ControlProblem
{
public:
  LinearizedControlProblem();
  LinearizedControlProblem(const ControlProblem & pb);
 
  TaskWithRequirementsPtr add(const Task & task, const requirements::SolvingRequirements & req = {});
  template<constraint::Type T>
  TaskWithRequirementsPtr add(utils::ProtoTask<T> proto,
                              const task_dynamics::abstract::TaskDynamics & td,
                              const requirements::SolvingRequirements & req = {});
  template<constraint::Type T>
  TaskWithRequirementsPtr add(utils::LinearProtoTask<T> proto,
                              const task_dynamics::abstract::TaskDynamics & td,
                              const requirements::SolvingRequirements & req = {});
  template<constraint::Type T>
  TaskWithRequirementsPtr add(utils::LinearProtoTask<T> proto, const requirements::SolvingRequirements & req = {});
  void add(TaskWithRequirementsPtr tr);
  void remove(const TaskWithRequirements & tr);
 
  void add(const hint::Substitution & s);
  void remove(const hint::Substitution & s);
  const hint::internal::Substitutions & substitutions() const;
  void removeSubstitutionFor(const constraint::abstract::LinearConstraint & cstr);
 
  VariableVector variables() const;
 
  std::vector<LinearConstraintWithRequirements> constraints() const;
 
  LinearConstraintPtr constraint(const TaskWithRequirements & t) const;
 
  LinearConstraintPtr constraintNoThrow(const TaskWithRequirements & t) const;
 
  const LinearConstraintWithRequirements & constraintWithRequirements(const TaskWithRequirements & t) const;
 
  std::optional<std::reference_wrapper<const LinearConstraintWithRequirements>> constraintWithRequirementsNoThrow(
      const TaskWithRequirements & t) const;
 
  const tvm::utils::internal::map<TaskWithRequirements const *, LinearConstraintWithRequirements> & constraintMap()
      const;
 
protected:
  void update_() override;
 
  void finalize_() override;
 
private:
  utils::internal::map<TaskWithRequirements const *, LinearConstraintWithRequirements> constraints_;
  hint::internal::Substitutions substitutions_;
};
 
template<constraint::Type T>
TaskWithRequirementsPtr LinearizedControlProblem::add(utils::ProtoTask<T> proto,
                                                      const task_dynamics::abstract::TaskDynamics & td,
                                                      const requirements::SolvingRequirements & req)
{ return add({proto, td}, req); }
 
template<constraint::Type T>
TaskWithRequirementsPtr LinearizedControlProblem::add(utils::LinearProtoTask<T> proto,
                                                      const task_dynamics::abstract::TaskDynamics & td,
                                                      const requirements::SolvingRequirements & req)
{ return add({proto, td}, req); }
 
template<constraint::Type T>
TaskWithRequirementsPtr LinearizedControlProblem::add(utils::LinearProtoTask<T> proto,
                                                      const requirements::SolvingRequirements & req)
{ return add({proto, task_dynamics::None()}, req); }
} // namespace tvm