ResolutionScheme.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/VariableVector.h>
#include <tvm/scheme/internal/ProblemComputationData.h>
#include <tvm/scheme/internal/ResolutionSchemeBase.h>
#include <tvm/scheme/internal/SchemeAbilities.h>
#include <tvm/utils/memoryChecks.h>
 
namespace tvm
{
 
class LinearizedControlProblem;
 
namespace scheme
{
 
namespace abstract
{
 
template<typename Derived>
class ResolutionScheme : public internal::ResolutionSchemeBase
{
public:
  template<typename Problem>
  bool solve(Problem & problem) const;
 
  template<typename Problem>
  std::unique_ptr<internal::ProblemComputationData> createComputationData(const Problem & problem) const;
 
  template<typename Problem>
  void updateComputationData(const Problem & problem, internal::ProblemComputationData * data) const;
 
  Derived & derived() { return *static_cast<Derived *>(this); }
  const Derived & derived() const { return *static_cast<const Derived *>(this); }
 
protected:
  ResolutionScheme(internal::SchemeAbilities abilities, double big = constant::big_number);
};
 
template<typename Derived>
class LinearResolutionScheme : public ResolutionScheme<Derived>
{
protected:
  LinearResolutionScheme(internal::SchemeAbilities abilities, double big = constant::big_number);
};
 
template<typename Derived>
template<typename Problem>
inline bool ResolutionScheme<Derived>::solve(Problem & problem) const
{
  auto data = getComputationData(problem, *this);
  problem.update();
  updateComputationData(problem, data);
  bool b = derived().solve_(problem, data);
  data->setVariablesToSolution();
  problem.substitutions().updateVariableValues();
  return b;
}
 
template<typename Derived>
template<typename Problem>
inline std::unique_ptr<internal::ProblemComputationData> ResolutionScheme<Derived>::createComputationData(
    const Problem & problem) const
{
  tvm::utils::override_is_malloc_allowed(true);
  return derived().createComputationData_(problem);
  tvm::utils::restore_is_malloc_allowed();
}
 
template<typename Derived>
template<typename Problem>
void ResolutionScheme<Derived>::updateComputationData(const Problem & problem,
                                                      internal::ProblemComputationData * data) const
{
  tvm::utils::override_is_malloc_allowed(true);
  derived().updateComputationData_(problem, data);
  tvm::utils::restore_is_malloc_allowed();
}
 
template<typename Derived>
inline ResolutionScheme<Derived>::ResolutionScheme(internal::SchemeAbilities abilities, double big)
: ResolutionSchemeBase(abilities, big)
{}
 
template<typename Derived>
inline LinearResolutionScheme<Derived>::LinearResolutionScheme(internal::SchemeAbilities abilities, double big)
: ResolutionScheme<Derived>(abilities, big)
{}
 
} // namespace abstract
 
} // namespace scheme
 
} // namespace tvm
 
#include <tvm/scheme/internal/helpers.hpp>