WeightedLeastSquares.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/LeastSquareSolver.h>
 
namespace tvm
{
 
namespace scheme
{
class TVM_DLLAPI WeightedLeastSquaresOptions
{
  TVM_ADD_NON_DEFAULT_OPTION(autoDamping, false)
  TVM_ADD_NON_DEFAULT_OPTION(scalarizationWeight, 1000.)
};
 
class TVM_DLLAPI WeightedLeastSquares : public abstract::LinearResolutionScheme<WeightedLeastSquares>
{
private:
  struct Memory : public internal::LinearizedProblemComputationData
  {
    Memory(int solverId, std::unique_ptr<solver::abstract::LeastSquareSolver> solver);
 
    void reset(std::unique_ptr<solver::abstract::LeastSquareSolver> solver);
 
    std::unique_ptr<solver::abstract::LeastSquareSolver> solver;
 
    int maxp = 0;
 
  protected:
    void setVariablesToSolution_(tvm::internal::VariableCountingVector & x) override;
  };
 
  const static internal::SchemeAbilities abilities_;
 
  template<typename T>
  using isFactory = std::is_base_of<solver::abstract::LSSolverFactory, T>;
  template<typename T>
  struct FactoryMemberIsFactory
  {
    static constexpr bool value = isFactory<typename T::Factory>::value;
  };
  template<typename T>
  using isLSSolverFactoryOption =
      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>
  WeightedLeastSquares(const SolverFactory & solverFactory, WeightedLeastSquaresOptions schemeOptions = {})
  : LinearResolutionScheme<WeightedLeastSquares>(abilities_), options_(schemeOptions),
    solverFactory_(solverFactory.clone())
  {}
 
  template<class SolverOptions, typename std::enable_if<isLSSolverFactoryOption<SolverOptions>::value, int>::type = 0>
  WeightedLeastSquares(const SolverOptions & solverOptions, WeightedLeastSquaresOptions schemeOptions = {})
  : WeightedLeastSquares(typename SolverOptions::Factory(solverOptions), schemeOptions)
  {}
 
  template<typename T,
           typename std::enable_if<!isFactory<T>::value && !isLSSolverFactoryOption<T>::value, int>::type = 0>
  WeightedLeastSquares(const T &, WeightedLeastSquaresOptions = {})
  : LinearResolutionScheme<WeightedLeastSquares>(abilities_)
  {
    static_assert(tvm::internal::always_false<T>::value,
                  "First argument can only be a LSSolverFactory or a solver configuration. "
                  "A configuration needs to have a Factory member type that is itself deriving from LSSolverFactory. "
                  "See LSSOLLSSolverOptions for an example.");
  }
 
  WeightedLeastSquares(const WeightedLeastSquares &) = delete;
  WeightedLeastSquares(WeightedLeastSquares &&) = delete;
  WeightedLeastSquares & operator=(const WeightedLeastSquares &) = delete;
  WeightedLeastSquares & operator=(WeightedLeastSquares &&) = 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;
 
  WeightedLeastSquaresOptions options_;
  std::unique_ptr<solver::abstract::LSSolverFactory> solverFactory_;
};
 
} // namespace scheme
 
} // namespace tvm