sgapprox.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 _SGAPPROX_HPP
#define _SGAPPROX_HPP
 
#include "sgcommon.hpp"
#include "sgutilities.hpp"
#include "sgenv.hpp"
#include "sggame.hpp"
#include "sgexception.hpp"
#include "sgsolution_pencilsharpening.hpp"
#include "sgnamespace.hpp"
 
 
class SGApprox
{
private:
  const SGEnv & env; 
  const SGGame & game; 
  SGSolution_PencilSharpening & soln; 
  const double delta; 
  const int numPlayers; 
  const int numStates; 
  std::ofstream logfs; 
  int numIterations; 
  int numRevolutions; 
  double errorLevel; 
  vector<bool> facingEastNorth; 
  bool passNorth; 
  bool sufficiencyFlag; 
  vector<bool> updatedThreatTuple; 
  vector< list<SGAction_PencilSharpening> > actions; 
  vector<SGTuple> extremeTuples; 
  SGTuple threatTuple; 
  SGTuple pivot; 
  SGPoint currentDirection; 
  vector< const SGAction_PencilSharpening* > actionTuple; 
  vector<SG::Regime> regimeTuple; 
  list<SGAction_PencilSharpening>::const_iterator bestAction; 
  SGPoint bestDirection; 
  SG::Regime bestRegime; 
  SGAction_PencilSharpening nullAction; 
  int westPoint; 
  int newWest; 
  int oldWest; 
 
  void updateMinPayoffs();
 
 
  void calculateBindingContinuations();
 
 
  void trimBindingContinuations() ;
 
 
  void findBestDirection();
 
 
  void calculateNewPivot();
 
 
  double updatePivot(vector<double> & movements, 
             vector<double> & changes,
             vector<SG::Regime> & regimeTuple,
             const vector<double> & maxMovement,
             const vector<SG::Regime> & maxMovementConstraints);
 
 
  void updateFlags();
 
 
  double distance(int newStart, int newEnd, int oldStart, int oldEnd) const;
 
  double distHelper(const SGPoint & p, 
            const SGPoint & qA, 
            const SGPoint & qB) const;
 
 
  bool improves(const SGPoint & current, 
        const SGPoint & best, 
        const SGPoint & newDirection) const;
 
  void logAppend(ofstream & logfs,
         int iter, int rev, const SGTuple & tuple,
         int state, int action);
 
public:
  SGApprox(const SGEnv & _env,
       const SGGame & _game,
       SGSolution_PencilSharpening & _soln):
    env(_env), game(_game), soln(_soln),
    delta(game.getDelta()), numPlayers(game.getNumPlayers()),
    numStates(game.getNumStates()), errorLevel(1), sufficiencyFlag(true),
    nullAction(env)
  { }
  
 
  void initialize();
 
  int getNumIterations() const {return numIterations; }
  int getNumRevolutions() const {return numRevolutions; }
  int getNumExtremeTuples() const {return extremeTuples.size(); }
  SG::Regime getBestRegime() const {return bestRegime; }
  list<SGAction_PencilSharpening>::const_iterator  getBestAction() const { return bestAction; }
  const SGPoint & getBestDirection() const { return bestDirection; }
  const vector<const SGAction_PencilSharpening*> & getActionTuple() const { return actionTuple; }
  const vector<SG::Regime> & getRegimeTuple() const { return regimeTuple; }
  const SGPoint & getDirection() const { return currentDirection; }
  const SGTuple & getPivot() const {return pivot; }
  const SGTuple & getThreatTuple() const {return threatTuple; }
  const vector< list<SGAction_PencilSharpening> > & getActions() const { return actions; }
  const vector<SGTuple> & getExtremeTuples() const {return extremeTuples; }
 
  std::string progressString() const;
 
 
  double generate(bool storeIteration = true);
 
 
  bool passedNorth() const
  {return passNorth; }
 
 
  void end();
 
};
 
 
#endif