bcesolver.hpp

// This file is part of the BCESolve library for games of incomplete
// information
// Copyright (C) 2022 Benjamin A. Brooks
// 
// BCESolve free software: you can redistribute it and/or modify it
// under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// BCESolve is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see
// <http://www.gnu.org/licenses/>.
// 
// Benjamin A. Brooks
// ben@benjaminbrooks.net
// Chicago, IL
 
#ifndef BCESOLVER_HPP
#define BCESOLVER_HPP
 
#include "bcecommon.hpp"
#include "bcegame.hpp"
#include "bcesolution.hpp"
#include "bcecounter.hpp"
#include "bceexception.hpp"
#include "bceutilities.hpp"
#include "gurobi_c++.h"
 
 
class BCESolver 
{
public:
 
 
  enum DoubleParameter
    {
      MinAngleIncrement
    };
 
  enum IntParameter
    {
      CurrentObjective,
 
      DisplayLevel, 
      BoundaryObjective1, 
      BoundaryObjective2 
    };
  
 
  enum BoolParameter
    {
    };
 
  void setMinAngleIncr(double incr) {
    minAngleIncrement = incr;
  }
 
protected:
  BCEAbstractGame * game; 
 
  long int numColumns; 
  long int numRows; 
  long int numNonBasicVariables; 
 
  long int numActions_total; 
  long int numTypes_total; 
  long int numActionsTypesPerPlayer_total; 
  long int numActionsTypes_total; 
 
  // Stores the # of IC constraints for each player.
  vector<int> numICConstraints; 
  long int numICConstraints_total;
  long int numProbabilityVariables; 
  long int numProbabilityConstraints; 
 
  // Gurobi components
 
  GRBEnv env;  
  GRBLinExpr gurobiObjective; 
 
  GRBVar* variables; 
  vector<GRBLinExpr> constraints; 
 
  // We allow the user to define any number of objective functions.
  // These are all stored in an array obfun. The index of the current
  // objective is currentobfun. 
 
  vector<GRBLinExpr> objectiveFunctions; 
 
  bool isPopulated;
  
 
  list<int> nonZeroVariableLocations;
 
  vector<int> probabilityConstraintLocations; 
 
  map<int,int> variableLocationsMap;
 
 
  double minAngleIncrement;
  int currentObjective;
 
  int displayLevel; 
 
  // Lists for storing equilibria and boundary points.
 
  list<double> boundaryXs;
 
  list<double> boundaryYs; 
  BCESolution soln; 
 
  void countActionsTypes();
 
  // Helper functions. These functions map between a linear index i
  // and valuations, types, and states. Mostly deprecated because of
  // use of BCECounter class.
  void indexToTypeActionDeviation(int index, int player, int &type, int &action, int &deviation);
 
public:
 
  BCESolver(); 
 
 
  BCESolver(BCEAbstractGame & _game);
 
  GRBModel model;
 
  ~BCESolver()
  { delete[] variables; } 
 
  // Main routines
 
 
  void populate(); 
 
 
  void solve(vector<double>& objectiveWeights);
 
 
  void mapBoundary(const char * fname);
 
 
  void mapBoundary();
 
 
  void mapBoundary(const char * fname,
           const vector<vector<double> >& weights);
 
 
  void mapBoundary(const vector<vector<double> >& weights);
 
 
  void getSolution(BCESolution & output);
 
 
  void bceToMap(map<int,double> & distribution);
  
  // Get methods
  GRBModel& getModel() { return model; }
  const GRBLinExpr& getObjectiveFunction (int n) const { return objectiveFunctions[n]; }
  GRBLinExpr& getObjective() { return gurobiObjective; }
 
  // Clear
  void clear();
 
  // Set methods
  void setParameter(BCESolver::DoubleParameter, double arg);
  void setParameter(BCESolver::IntParameter, int arg);
  void setParameter(BCESolver::BoolParameter, bool arg);
  void setObfun(int n) { gurobiObjective = objectiveFunctions[n]; }
 
  // get methods
  double getParameter(BCESolver::DoubleParameter);
  int getParameter(BCESolver::IntParameter);
  bool getParameter(BCESolver::BoolParameter);
 
  // Can't believe this doesn't exist in ANSI C++
  static int pow(int base, int exponent)
  {
    int result=1;
    for (int exponentCounter=0; exponentCounter<exponent; exponentCounter++)
      result*=base;
    return result;
  }
};
 
#endif