sgbaseaction.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 _SGBASEACTION_HPP
#define _SGBASEACTION_HPP
 
#include "sgcommon.hpp"
#include "sgtuple.hpp"
#include "sgnamespace.hpp"
 
 
class SGBaseAction
{
protected:
  int numPlayers; 
  int state; 
  int action; 
  SGPoint minIC; 
  vector< SGTuple > points; 
  vector<SGTuple> bndryDirs; 
  vector< vector< int > > tuples; 
  bool isNull; 
  bool corner; 
public:
 
  SGBaseAction():
    numPlayers(2),
    isNull(true),
    action(-1),
    state(-1)
  {}
 
 
  SGBaseAction(int _state, int _action):
    SGBaseAction(2,_state,_action)
  { }
  
 
  SGBaseAction(int _numPlayers,
           int _state,
           int _action):
    numPlayers(_numPlayers),
    state(_state),
    action(_action),
    minIC(_numPlayers,-numeric_limits<double>::max()),
    points(numPlayers),
    bndryDirs(_numPlayers,SGTuple(2)),
    isNull(false),
    corner(false)
  {
    tuples.resize(numPlayers); 
  }
 
  ~SGBaseAction() {}
  
  bool getIsNull() const {return isNull;}
  int getAction() const { return action; }
  const vector<SGTuple> & getPoints() const { return points; }
  const vector<SGTuple> & getBndryDirs() const { return bndryDirs; }
  const vector< vector<int> > & getTuples() const { return tuples; }
  int getState() const { return state; }
  bool hasCorner() const { return corner; }
  const SGPoint & getMinICPayoffs() const {return minIC;}
  const vector<SGTuple> & getBindingContinuations() const { return points; }
 
  void setMinICPayoffs(const SGPoint & newMinIC)
  {
    minIC = newMinIC;
  } // setMinIC
  void setTuples(const vector< vector<int> > & newTuples)
  {
    assert(newTuples.size()<=numPlayers);
    tuples = newTuples;
  } // setTuples
  void setPoints(const vector<SGTuple> & newPoints)
  {
    assert(newPoints.size()<=numPlayers);
    points = newPoints;
  } // setPoints
  void setPointsAndTuples(const vector<SGTuple> & newPoints,
              const vector< vector<int> > & newTuples)
  {
    assert(newPoints.size() <= numPlayers);
    assert(newPoints.size() == newTuples.size());
    points = newPoints;
    tuples = newTuples;
  } // setPointsAndTuples
 
  void setCorner(bool tf)
  {
    corner=tf;
  }
 
  bool isCorner(const int p, const int k) const;
 
  template<class Archive>
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & numPlayers;
    ar & state;
    ar & action;
    ar & minIC;
    ar & points;
    ar & tuples;
    ar & bndryDirs;
    ar & isNull;
    ar & corner;
  } // serialize
 
  friend class boost::serialization::access;
}; // SGBaseAction
 
 
#endif