sgaction_maxminmax.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
 
// Classes for storing data for stochastic games.
#ifndef _SGACTION_MAXMINMAX_HPP
#define _SGACTION_MAXMINMAX_HPP
 
#include "sgcommon.hpp"
#include "sgtuple.hpp"
#include "sgenv.hpp"
#include "sggame.hpp"
#include "sgbaseaction.hpp"
#include "sghyperplane.hpp"
 
 
 
class SGAction_MaxMinMax : public SGBaseAction
{
private:
  const SGEnv * env; 
  vector<SGTuple> trimmedPoints; 
  vector<SGTuple> trimmedBndryDirs; 
public:
  SGAction_MaxMinMax():
    env(new SGEnv()),
    SGBaseAction()
  {}
  
 
  SGAction_MaxMinMax(const SGEnv & _env):
    env(&_env),
    SGBaseAction()
  {}
 
 
  SGAction_MaxMinMax(const SGEnv & _env,
             int _state,
             int _action):
    SGAction_MaxMinMax(_env,2,_state,_action)
  {}
 
 
  SGAction_MaxMinMax(const SGEnv & _env,
             int _numPlayers,
             int _state,
             int _action):
    env(&_env),
    SGBaseAction(_numPlayers,_state,_action),
    trimmedBndryDirs(_numPlayers,SGTuple(2,SGPoint(2,0.0)))
  {
    trimmedPoints.resize(_numPlayers);
    // cout << numPlayers << endl;
  }
 
 
  void resetTrimmedPoints();
  
 
  void resetTrimmedPoints(const SGPoint & payoffUB);
  
  void updateTrim();
 
  double distToTrimmed() const;
 
  bool intersectHalfSpace(const SGPoint & normal,
              const double level,
              int player,
              SGTuple & segment,
              SGTuple & segmentDirs);
 
  bool intersectPolygonHalfSpace(const SGPoint & normal,
                 const double level,
                 int player,
                 SGTuple & extPnts,
                 SGTuple & extPntDirs);
  
 
  bool trim(const SGPoint & normal,
        double level);
 
  void mergeDuplicatePoints(const double tol);
 
  void calculateMinIC(const SGGame & game,
              const vector<bool> & update,
              const SGTuple & threatTuple);
 
  void calculateMinIC(const SGGame & game,
              const SGTuple & threatTuple)
  {
    calculateMinIC(game,vector<bool>(numPlayers,true),threatTuple);
  }
 
 
  static double calculateMinIC(int action,int state, int player,
                   const SGGame & game,
                   const SGTuple & threatTuple);
 
  const vector<SGTuple> & getTrimmedPoints() const { return trimmedPoints; }
 
  const vector<SGTuple> & getTrimmedBndryDirs() const { return trimmedBndryDirs; }
 
 
  const SGPoint getBndryDir(const int player,const int point) const;
  
  // Returns whether the action can be supported
  bool supportable() const;
 
}; // SGAction_MaxMinMax
 
 
bool operator==(const SGAction_MaxMinMax & lhs,
        const SGAction_MaxMinMax & rhs);
 
 
bool operator<(const SGAction_MaxMinMax & lhs,
           const SGAction_MaxMinMax & rhs);
 
template class std::list<SGAction_MaxMinMax>;
/*template std::list<SGAction_MaxMinMax>::const_iterator;
  template std::list<SGAction_MaxMinMax>::iterator; */
 
typedef list<SGAction_MaxMinMax>::const_iterator SGActionIter;
 
#endif