lcptolp.h

Go to the documentation of this file.

#pragma once

#include "epecsolve.h"
#include <armadillo>
#include <gurobi_c++.h>
#include <iostream>
#include <memory>
#include <set>

// using namespace Game;

namespace Game {

arma::vec LPSolve(const arma::sp_mat &A, const arma::vec &b, const arma::vec &c,
                  int &status, bool Positivity = false);

unsigned int ConvexHull(const std::vector<arma::sp_mat *> *Ai,
                        const std::vector<arma::vec *> *bi, arma::sp_mat &A,
                        arma::vec &b, const arma::sp_mat Acom = {},
                        const arma::vec bcom = {});

void compConvSize(arma::sp_mat &A, const unsigned int nFinCons,
                  const unsigned int nFinVar,
                  const std::vector<arma::sp_mat *> *Ai,
                  const std::vector<arma::vec *> *bi, const arma::sp_mat &Acom,
                  const arma::vec &bcom);
class LCP {
  using spmat_Vec = std::vector<std::unique_ptr<arma::sp_mat>>;
  using vec_Vec = std::vector<std::unique_ptr<arma::vec>>;

private:
  // Essential data ironment for MIP/LP solves
  GRBEnv *env;    
  arma::sp_mat M; 
  arma::vec q;    
  perps Compl;    
  unsigned int LeadStart{1}, LeadEnd{0}, nLeader{0};
  arma::sp_mat _A = {};
  arma::vec _b = {}; 
  // Temporary data
  bool madeRlxdModel{false}; 
  unsigned int nR, nC;

  int polyCounter{0};
  unsigned int feasiblePolyhedra{0};
  unsigned int sequentialPolyCounter{0};
  int reverseSequentialPolyCounter{0};
  std::set<unsigned long int> AllPolyhedra =
      {}; 
  std::set<unsigned long int> feasiblePoly =
      {}; 
  std::set<unsigned long int> knownInfeas =
      {}; 
  unsigned long int maxTheoreticalPoly{0};
  std::unique_ptr<spmat_Vec>
      Ai; 
  std::unique_ptr<vec_Vec>
      bi;             
  GRBModel RlxdModel; 

  bool errorCheck(bool throwErr = true) const;
  void defConst(GRBEnv *env);
  void makeRelaxed();
  void initializeNotProcessed() {
    const unsigned int nCompl = this->Compl.size();
    // 2^n - the number of polyhedra theoretically
    this->maxTheoreticalPoly = static_cast<unsigned long int>(pow(2, nCompl));
    sequentialPolyCounter = 0;
    reverseSequentialPolyCounter = this->maxTheoreticalPoly - 1;
  }
  /* Solving relaxations and restrictions */
  std::unique_ptr<GRBModel> LCPasMIP(std::vector<unsigned int> FixEq = {},
                                     std::vector<unsigned int> FixVar = {},
                                     bool solve = false);
  std::unique_ptr<GRBModel> LCPasMIP(std::vector<short int> Fixes, bool solve);
  std::unique_ptr<GRBModel>
  LCP_Polyhed_fixed(std::vector<unsigned int> FixEq = {},
                    std::vector<unsigned int> FixVar = {});
  std::unique_ptr<GRBModel> LCP_Polyhed_fixed(arma::Col<int> FixEq,
                                              arma::Col<int> FixVar);
  template <class T> inline bool isZero(const T val) const {
    return (val >= -eps && val <= eps);
  }
  inline std::vector<short int> solEncode(GRBModel *model) const;
  std::vector<short int> solEncode(const arma::vec &x) const;
  std::vector<short int> solEncode(const arma::vec &z,
                                   const arma::vec &x) const;
  bool FixToPoly(const std::vector<short int> Fix, bool checkFeas = false,
                 bool custom = false, spmat_Vec *custAi = {},
                 vec_Vec *custbi = {});
  LCP &FixToPolies(const std::vector<short int> Fix, bool checkFeas = false,
                   bool custom = false, spmat_Vec *custAi = {},
                   vec_Vec *custbi = {});
  unsigned long int getNextPoly(Game::EPECAddPolyMethod method);

public:
  // Fudgible data
  long double bigM{1e7}; 
  long double eps{
      1e-6}; 
  long double eps_int{1e-8}; 
  bool useIndicators{
      true}; 
  long int addPolyMethodSeed = {
      -1}; 

  LCP() = delete;

  LCP(GRBEnv *e)
      : env{e},
        RlxdModel(*e){}; 

  LCP(GRBEnv *env, arma::sp_mat M, arma::vec q, unsigned int LeadStart,
      unsigned LeadEnd, arma::sp_mat A = {},
      arma::vec b = {}); // Constructor with M,q,leader posn
  LCP(GRBEnv *env, arma::sp_mat M, arma::vec q, perps Compl,
      arma::sp_mat A = {},
      arma::vec b = {}); // Constructor with M, q, compl pairs
  LCP(GRBEnv *env, const Game::NashGame &N);
  // LCP(const LCP &) = default;
  // LCP &operator=(const LCP &) = default;

  ~LCP();

  inline arma::sp_mat getM() { return this->M; } 
  inline arma::sp_mat *getMstar() {
    return &(this->M);
  }                                           
  inline arma::vec getq() { return this->q; } 
  inline arma::vec *getqstar() {
    return &(this->q);
  } 
  inline unsigned int getLStart() {
    return LeadStart;
  } 
  inline unsigned int getLEnd() {
    return LeadEnd;
  } 
  inline perps getCompl() {
    return this->Compl;
  }                                   
  void print(std::string end = "\n"); 
  inline unsigned int getNcol() { return this->M.n_cols; };

  inline unsigned int getNrow() { return this->M.n_rows; };

  bool extractSols(GRBModel *model, arma::vec &z, arma::vec &x,
                   bool extractZ = false) const;

  /* Getting single point solutions */
  std::unique_ptr<GRBModel> LCPasQP(bool solve = false);
  std::unique_ptr<GRBModel> LCPasMIP(bool solve = false);
  std::unique_ptr<GRBModel> MPECasMILP(const arma::sp_mat &C,
                                       const arma::vec &c,
                                       const arma::vec &x_minus_i,
                                       bool solve = false);
  std::unique_ptr<GRBModel>
  MPECasMIQP(const arma::sp_mat &Q, const arma::sp_mat &C, const arma::vec &c,
             const arma::vec &x_minus_i, bool solve = false);
  /* Convex hull computation */
  unsigned int ConvexHull(arma::sp_mat &A, arma::vec &b);
  unsigned int conv_Npoly() const;
  unsigned int conv_PolyPosition(const unsigned long int i) const;
  unsigned int conv_PolyWt(const unsigned long int i) const;

  std::set<unsigned long int> getAllPolyhedra() const {
    return this->AllPolyhedra;
  };
  unsigned long int getNumTheoreticalPoly() const noexcept {
    return this->maxTheoreticalPoly;
  }

  LCP &makeQP(Game::QP_objective &QP_obj, Game::QP_Param &QP);

  std::set<std::vector<short int>>
  addAPoly(unsigned long int nPoly = 1,
           Game::EPECAddPolyMethod method = Game::EPECAddPolyMethod::sequential,
           std::set<std::vector<short int>> Polys = {});
  bool addThePoly(const unsigned long int &decimalEncoding);
  bool checkPolyFeas(const unsigned long int &decimalEncoding);
  bool checkPolyFeas(const std::vector<short int> &Fix);
  void clearPolyhedra() {
    this->Ai->clear();
    this->bi->clear();
    this->AllPolyhedra.clear();
  }
  LCP &addPolyFromX(const arma::vec &x, bool &ret);
  LCP &EnumerateAll(bool solveLP = true);
  std::string feas_detail_str() const;
  unsigned int getFeasiblePolyhedra() const { return this->feasiblePolyhedra; }
  void write(std::string filename, bool append = true) const;
  void save(std::string filename, bool erase = true) const;
  long int load(std::string filename, long int pos = 0);
};
} // namespace Game

/* Example for LCP  */