sggame.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 _SGGAME_HPP
#define _SGGAME_HPP
 
#include "sgcommon.hpp"
#include "sgutilities.hpp"
#include "sgexception.hpp"
#include "sgtuple.hpp"
#include "sgabstractgame.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/utility.hpp>
 
 
class SGGame
{
protected: 
  double delta; 
  int numPlayers; 
  int numStates; 
  vector< vector<int> > numActions; 
  vector<int> numActions_total; 
  vector< vector<SGPoint> > payoffs; 
  vector< vector< vector<double> > > probabilities; 
  vector< vector<bool> > eqActions; 
  vector<bool> unconstrained; 
  template <class Archive> 
  void serialize(Archive& ar, const unsigned int version)
  {
    ar & delta;
    ar & numPlayers;
    ar & numStates;
    ar & numActions;
    ar & numActions_total;
    ar & payoffs;
    ar & probabilities;
    ar & eqActions;
    ar & unconstrained;
  }
 
public:
  SGGame():
    numStates(1),
    numActions(1,vector<int>(2,1)),
    numActions_total(1,1),
    payoffs(1,vector<SGPoint>(1,SGPoint(0,0))),
    probabilities(1,vector< vector<double> > (1,vector<double> (1,1))),
    delta(0.9),
    numPlayers(2),
    unconstrained(2,false)
  {}
 
 
  SGGame(const SGAbstractGame & game);
    
  ~SGGame() {}
 
  SGGame(double _delta,
     int _numStates,
     const vector< vector<int> > & _numActions,
     const vector< vector< vector<double> > > & _payoffs,
     const vector< vector< vector<double> > > & _probabilities);
 
  SGGame(double _delta,
     int _numStates,
     const vector< vector<int> > & _numActions,
     const vector< vector< vector<double> > > & _payoffs,
     const vector< vector< vector<double> > > & _probabilities,
     const vector<bool> & _unconstrained);
 
 
  SGGame(double _delta,
     int _numStates,
     const vector< vector<int> > & _numActions,
     const vector< vector< vector<double> > > & _payoffs,
     const vector< vector< vector<double> > > & _probabilities,
     const vector< vector<bool> > & _eqActions,
     const vector<bool> & _unconstrained);
 
 
  SGGame(int _numPlayers,
     double _delta,
     int _numStates,
     const vector< vector<int> > & _numActions,
     const vector< vector< vector<double> > > & _payoffs,
     const vector< vector< vector<double> > > & _probabilities,
     const vector< vector<bool> > & _eqActions,
     const vector<bool> & _unconstrained);
  
  double getDelta() const { return delta; }  
  int getNumPlayers() const { return numPlayers; }
  int getNumStates() const { return numStates; }
  const vector< vector<int> > & getNumActions() const
  { return numActions; }
  const vector<int> & getNumActions_total () const
  { return numActions_total; }
  const vector< vector< vector<double> > > & getProbabilities() const
  {return probabilities;}
  const vector< vector<SGPoint> > & getPayoffs() const
  { return payoffs; }
  const vector< vector<bool> > & getEquilibriumActions() const
  { return eqActions; }
  void getPayoffBounds(SGPoint & UB, SGPoint & LB) const;
 
  const vector<bool> & getConstrained() const
  { return unconstrained; }
 
 
  bool setDiscountFactor(double newDelta);
 
  bool setPayoff(int state, int action, int player, double payoff);
 
  bool setProbability(int state, int action,
              int newState, double prob);
  bool setConstrained(const vector<bool> & _unconstrained);
 
  bool addAction(int state, int player, int position);
  bool removeAction(int state, int player, int action);
 
  bool addState(int position);
  bool removeState(int state);
 
  bool transitionProbsSumToOne(double tolerance=1e-3) const;
 
  bool profitableDeviation(vector<int> & input, SGGame game);
  
  static void save(const SGGame & game, const char* filename)
  {
    std::ofstream ofs(filename);
 
    if (ofs.good())
      {
    boost::archive::text_oarchive oa(ofs);
    oa << game;
      }
    else
      throw(SGException(SG::FAILED_OPEN));
  }
 
  static void load(SGGame & game, const char* filename)
  {
    std::ifstream ifs(filename);
    if (ifs.good())
      {
    boost::archive::text_iarchive ia(ifs);
    ia >> game;
      }
    else
      throw(SGException(SG::FAILED_OPEN));
  }
 
  friend class boost::serialization::access;
  friend class SGSolver;
};
 
#endif