sgsolver_maxminmax_3player.hpp

// This file is part of the SGSolve library for stochastic games
// Copyright (C) 2019 Benjamin A. Brooks
// 
// SGSolve 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.
// 
// SGSolve 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 _SGSOLVER_MAXMINMAX_3PLAYER_HPP
#define _SGSOLVER_MAXMINMAX_3PLAYER_HPP
 
#include "sgcommon.hpp"
#include "sgutilities.hpp"
#include "sgenv.hpp"
#include "sggame.hpp"
#include "sgaction_maxminmax.hpp"
#include "sgexception.hpp"
#include "sgsolution_maxminmax.hpp"
#include "sgedgepolicy.hpp"
 
 
class SGSolver_MaxMinMax_3Player
{
private:
  // Data
 
  const SGEnv & env;
  const SGGame & game; 
  SGSolution_MaxMinMax soln;
 
  // References to objects in the game
  const double delta; 
  const int numPlayers; 
  const int numStates; 
  const vector< vector<bool> > & eqActions; 
  const vector< vector<SGPoint> > & payoffs; 
  const vector< vector< vector<double> > > & probabilities; 
  const vector< vector<int> > numActions; 
  const vector< int > numActions_totalByState; 
  list<SGPoint> directions; 
  list< vector<double> > levels; 
  list<SGPoint> threatDirections;
  SGTuple threatTuple; 
  vector< list<SGAction_MaxMinMax> > actions; 
  const SGPoint dueEast = SGPoint(1.0,0.0); 
  const SGPoint dueNorth = SGPoint(0.0,1.0); 
  int numIter; 
  double errorLevel; 
  SGPoint payoffLB; 
  SGPoint payoffUB; 
  int numRedundDirs; 
  int numEndogDirs; 
  bool debugMode; 
public:
  SGSolver_MaxMinMax_3Player(); 
 
 
  SGSolver_MaxMinMax_3Player(const SGEnv & _env, 
       const SGGame & _game);
 
  ~SGSolver_MaxMinMax_3Player() {}
 
 
  void solve(const int numDirsApprox = 200,
         const bool dropRedundant = true,
         const bool addEndogenous = true);
 
 
  void solve_endogenous();
 
 
  double iterate_endogenous();
 
 
  double iterate(const int maxDirections,
               const bool dropRedundant,
               const bool addEndogenous);
  
  void initialize();
 
  std::string progressString() const;
  
  void optimizePolicy(SGTuple & pivot,
              vector<SGActionIter> & actionTuple,
              vector<SG::Regime> & regimeTuple,
              const SGPoint & currDir,
              const vector<list<SGAction_MaxMinMax> > & actions) const;
 
  bool computeOptimalPolicies(SGProductPolicy & optPolicies,
                  const SGTuple & pivot,
                  const SGPoint & currDir,
                  const vector<list<SGAction_MaxMinMax> > & actions) const;
  
  double sensitivity(SGPoint & optSubDir,
             const SGTuple & pivot,
             const SGPoint & currDir,
             const SGPoint & newDir,
             const vector<list<SGAction_MaxMinMax> > & actions) const;
 
  void policyToPayoffs(SGTuple & pivot,
               const vector<SGActionIter>  & actionTuple,
               const vector<SG::Regime> & regimeTuple) const;
 
  const SGSolution_MaxMinMax& getSolution() const {return soln;}
};
 
 
#endif