Assignment.h

Go to the documentation of this file.

/* Copyright 2017-2020 CNRS-AIST JRL and CNRS-UM LIRMM */
 
#pragma once
 
#include <tvm/api.h>
#include <tvm/defs.h>
 
#include <tvm/Variable.h> // Range
#include <tvm/constraint/abstract/LinearConstraint.h>
#include <tvm/hint/internal/Substitutions.h>
#include <tvm/requirements/SolvingRequirements.h>
#include <tvm/scheme/internal/AssignmentTarget.h>
#include <tvm/scheme/internal/CompiledAssignmentWrapper.h>
#include <tvm/scheme/internal/MatrixAssignment.h>
 
#include <Eigen/Core>
 
#include <memory>
#include <type_traits>
#include <vector>
 
namespace tvm::scheme::internal
{
 
class TVM_DLLAPI Assignment
{
public:
  using RHSFunction = const Eigen::VectorXd & (constraint::abstract::LinearConstraint::*)() const;
 
  using MatrixFunction = MatrixRef (AssignmentTarget::*)(int, int) const;
 
  using VectorFunction = VectorRef (AssignmentTarget::*)() const;
 
  struct IWontForgetToCallUpdates
  {};
 
  Assignment(LinearConstraintPtr source,
             SolvingRequirementsPtr req,
             const AssignmentTarget & target,
             const VariableVector & variables,
             const hint::internal::Substitutions * const subs = nullptr,
             double scalarizationWeight = 1);
 
  Assignment(LinearConstraintPtr source, const AssignmentTarget & target, const VariablePtr & variables, bool first);
 
  Assignment(const Assignment &) = delete;
  Assignment(Assignment &&) = default;
  Assignment & operator=(const Assignment &) = delete;
  Assignment & operator=(Assignment &&) = default;
 
  static Assignment reprocess(const Assignment &, const VariableVector &, const hint::internal::Substitutions * const);
  static Assignment reprocess(const Assignment &, const VariablePtr &, bool);
 
  AssignmentTarget & target(IWontForgetToCallUpdates = {});
  bool changeScalarWeightIsAllowed();
  bool changeVectorWeightIsAllowed();
 
  void onUpdatedSource();
  void onUpdatedTarget();
  void onUpdatedMapping(const VariableVector & newVar, bool updateMatrixtarget = true);
  void onUpdateWeights(bool scalar = true, bool vector = true);
 
  void run();
 
  static double big_;
 
private:
  void checkTarget();
 
  void checkBounds();
 
  void build(const VariableVector & variables);
 
  void build(const VariablePtr & variable, bool first);
 
  void processRequirements();
 
  void addMatrixAssignment(Variable & x, MatrixFunction M, const Range & range, bool flip);
 
  void addMatrixSubstitutionAssignments(const VariableVector & variables,
                                        Variable & x,
                                        MatrixFunction M,
                                        const function::BasicLinearFunction & sub,
                                        bool flip);
 
  template<AssignType A = AssignType::COPY, typename From, typename To>
  void addVectorAssignment(const From & f, To v, bool flip, bool useFRHS = true, bool useTRHS = true);
 
  template<AssignType A = AssignType::COPY, typename From, typename To>
  void addVectorAssignment(const From & f,
                           To v,
                           const MatrixConstRef & D,
                           bool flip,
                           bool useFRHS = true,
                           bool useTRHS = true);
 
  void addVectorSubstitutionAssignments(const function::BasicLinearFunction & sub,
                                        VectorFunction v,
                                        Variable & x,
                                        bool flip);
 
  template<AssignType A = AssignType::COPY, typename To>
  void addVectorAssignment(double d, To v, bool flip = false, bool useFRHS = true, bool useTRHS = true);
 
  template<AssignType A = AssignType::COPY, typename To>
  void addVectorAssignment(double d,
                           To v,
                           const MatrixConstRef & D,
                           bool flip = false,
                           bool useFRHS = true,
                           bool useTRHS = true);
 
  void addZeroAssignment(Variable & x, MatrixFunction M, const Range & range);
 
  void addAssignments(const VariableVector & variables, MatrixFunction M, RHSFunction f, VectorFunction v, bool flip);
 
  void addAssignments(const VariableVector & variables,
                      MatrixFunction M,
                      RHSFunction f1,
                      VectorFunction v1,
                      RHSFunction f2,
                      VectorFunction v2);
 
  void addAssignments(const VariableVector & variables,
                      MatrixFunction M,
                      RHSFunction f1,
                      VectorFunction v1,
                      RHSFunction f2,
                      VectorFunction v2,
                      bool flip);
 
  void addBound(const VariablePtr & variable, RHSFunction f, bool first);
 
  template<typename L, typename U>
  void addBounds(const VariablePtr & variable, L l, U u, bool first);
 
  template<typename L, typename U, typename TL, typename TU>
  void addBounds(const VariablePtr & variable, L l, U u, TL tl, TU tu, bool first);
 
  template<typename T, AssignType A, typename U>
  CompiledAssignmentWrapper<T> createAssignment(const U & from, const Eigen::Ref<T> & to, bool flip = false);
 
  template<typename T, AssignType A, MatrixMult M = GENERAL, typename U, typename V>
  CompiledAssignmentWrapper<T> createMultiplicationAssignment(const U & from,
                                                              const Eigen::Ref<T> & to,
                                                              const V & Mult,
                                                              bool flip = false);
 
  LinearConstraintPtr source_;
  AssignmentTarget target_;
  double scalarizationWeight_;
  SolvingRequirementsPtr requirements_;
  bool useDefaultScalarWeight_;
  bool useDefaultAnisotropicWeight_;
  std::vector<MatrixAssignment> matrixAssignments_;
  std::vector<MatrixAssignment> matrixSubstitutionAssignments_;
  std::vector<VectorAssignment> vectorAssignments_;
  std::vector<VectorSubstitutionAssignement> vectorSubstitutionAssignments_;
 
  VariableVector substitutedVariables_;
  std::vector<std::shared_ptr<function::BasicLinearFunction>> variableSubstitutions_;
 
  struct ReferenceableData
  {
    double scalarWeight_ = 1;
    double minusScalarWeight_ = -1;
    Eigen::VectorXd anisotropicWeight_;
    Eigen::VectorXd minusAnisotropicWeight_;
 
    Eigen::VectorXd tmp1_;
    Eigen::VectorXd tmp2_;
    Eigen::VectorXd tmp3_;
    Eigen::VectorXd tmp4_;
  };
 
  std::unique_ptr<ReferenceableData> data_;
};
 
} // namespace tvm::scheme::internal
 
#include <tvm/scheme/internal/Assignment.hpp>