HierarchicalLeastSquares.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/internal/traits.h>
#include <tvm/scheme/abstract/ResolutionScheme.h>
#include <tvm/scheme/internal/Assignment.h>
#include <tvm/scheme/internal/LinearizedProblemComputationData.h>
#include <tvm/solver/abstract/HierarchicalLeastSquareSolver.h>
 
namespace tvm
{
 
namespace scheme
{
class TVM_DLLAPI HierarchicalLeastSquaresOptions
{
  TVM_ADD_NON_DEFAULT_OPTION(autoDamping, false)
};
 
class TVM_DLLAPI HierarchicalLeastSquares : public abstract::LinearResolutionScheme<HierarchicalLeastSquares>
{
private:
  struct Memory : public internal::LinearizedProblemComputationData
  {
    Memory(int solverId, std::unique_ptr<solver::abstract::HierarchicalLeastSquareSolver> solver);
 
    void reset(std::unique_ptr<solver::abstract::HierarchicalLeastSquareSolver> solver);
 
    std::unique_ptr<solver::abstract::HierarchicalLeastSquareSolver> solver;
 
  protected:
    void setVariablesToSolution_(tvm::internal::VariableCountingVector & x) override;
  };
 
  const static internal::SchemeAbilities abilities_;
 
  template<typename T>
  using isFactory = std::is_base_of<solver::abstract::HLSSolverFactory, T>;
  template<typename T>
  struct FactoryMemberIsFactory
  {
    static constexpr bool value = isFactory<typename T::Factory>::value;
  };
  template<typename T>
  using isHLSSolverFactoryOption =
      std::conjunction<tvm::internal::has_public_member_type_Factory<T>, FactoryMemberIsFactory<T>>;
 
public:
  using ComputationDataType = Memory;
 
  template<class SolverFactory, typename std::enable_if<isFactory<SolverFactory>::value, int>::type = 0>
  HierarchicalLeastSquares(const SolverFactory & solverFactory, HierarchicalLeastSquaresOptions schemeOptions = {})
  : LinearResolutionScheme<HierarchicalLeastSquares>(abilities_), options_(schemeOptions),
    solverFactory_(solverFactory.clone())
  {}
 
  template<class SolverOptions, typename std::enable_if<isHLSSolverFactoryOption<SolverOptions>::value, int>::type = 0>
  HierarchicalLeastSquares(const SolverOptions & solverOptions, HierarchicalLeastSquaresOptions schemeOptions = {})
  : HierarchicalLeastSquares(typename SolverOptions::Factory(solverOptions), schemeOptions)
  {}
 
  template<typename T,
           typename std::enable_if<!isFactory<T>::value && !isHLSSolverFactoryOption<T>::value, int>::type = 0>
  HierarchicalLeastSquares(const T &, HierarchicalLeastSquaresOptions = {})
  : LinearResolutionScheme<HierarchicalLeastSquares>(abilities_)
  {
    static_assert(tvm::internal::always_false<T>::value,
                  "First argument can only be a HLSSolverFactory or a solver configuration. "
                  "A configuration needs to have a Factory member type that is itself deriving from HLSSolverFactory. "
                  "See LexLSHLSSolverOptions for an example.");
  }
 
  HierarchicalLeastSquares(const HierarchicalLeastSquares &) = delete;
  HierarchicalLeastSquares(HierarchicalLeastSquares &&) = delete;
  HierarchicalLeastSquares & operator=(const HierarchicalLeastSquares &) = delete;
  HierarchicalLeastSquares & operator=(HierarchicalLeastSquares &&) = delete;
 
  bool solve_(const LinearizedControlProblem & problem, internal::ProblemComputationData * data) const;
  void updateComputationData_(const LinearizedControlProblem & problem, internal::ProblemComputationData * data) const;
  std::unique_ptr<Memory> createComputationData_(const LinearizedControlProblem & problem) const;
 
protected:
  void resetComputationData(const LinearizedControlProblem & problem, Memory * memory) const;
  void processProblem(const LinearizedControlProblem & problem, Memory * memory) const;
 
  void addTask(const LinearizedControlProblem & problem,
               Memory * memory,
               const TaskWithRequirements & task,
               solver::internal::SolverEvents & se) const;
  void removeTask(const LinearizedControlProblem & problem,
                  Memory * memory,
                  const TaskWithRequirements & task,
                  solver::internal::SolverEvents & se) const;
 
  HierarchicalLeastSquaresOptions options_;
  std::unique_ptr<solver::abstract::HLSSolverFactory> solverFactory_;
};
 
} // namespace scheme
 
} // namespace tvm