bceabstractgame.hpp

// This file is part of the BCESolve library for games of incomplete
// information
// Copyright (C) 2022 Benjamin A. Brooks
// 
// BCESolve 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.
// 
// BCESolve 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 BCEABSTRACTGAME_HPP
#define BCEABSTRACTGAME_HPP
 
#include <sstream>
#include "bcecommon.hpp"
#include "bceexception.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/vector.hpp>
 
 
 
class BCEAbstractGame 
{
 
protected:
  int numPlayers; 
  vector<int> numActions; 
  int numStates; 
  vector<int> numTypes; 
  int numObjectives; 
 
 
  bool hasProductStructureData;
 
  vector<int> numPrivateStates;
  vector<string> objectiveLabels;
 
 
public:
  BCEAbstractGame();
 
  BCEAbstractGame(int numStatesArg, 
          int numActionsArg, 
          int numTypesArg, 
          int numObjectivesArg);
 
  BCEAbstractGame(int numStatesArg, 
          const vector<int> & numActionsArg, 
          const vector<int> & numTypesArg, 
          int numObjectivesArg);
 
  ~BCEAbstractGame()
  {} 
 
  void setHasProductStructureData(bool hasProductStructure) {
    hasProductStructureData = hasProductStructure; 
  }
 
 
  virtual double prior(int state, const vector<int> &types) const = 0;
 
  double prior(const vector<int> & states, const vector<int> &types) const
  {
    if (hasProductStructureData
    && states[0] >= 0 && states[0] < numPrivateStates[0]
    && states[1] >= 0 && states[1] < numPrivateStates[1])
      return prior(states[0] + states[1]*numPrivateStates[0],types);
    return -99;
  }
 
 
  double prior(int state, int type, int player) const; // marginal distribution
 
 
  virtual double objective(int state, const vector<int> &actions, 
               int obj) const = 0; 
 
  double objective(const vector<int> &states, 
           const vector<int> &actions,
           int obj) const
  {
    if (hasProductStructureData
    && states[0] >= 0 && states[0] < numPrivateStates[0]
    && states[1] >= 0 && states[1] < numPrivateStates[1])
      return objective(states[0] + states[1]*numPrivateStates[0],
               actions,obj);
    return -99;
  }
 
 
  virtual bool dominated(int action, int type, int player) const
  {return false;};
 
 
  bool dominated(const vector<int> &actions, const vector<int> &types) const; 
 
 
  virtual bool feasibleDeviation(int action, int dev, 
                 int type, int player) const
  {return true;};
 
 
  bool setNumPrivateStates(const vector<int> & _numPrivateStates)
  {
    if (_numPrivateStates.size()!=numPlayers)
      throw(BCEException(BCEException::BadArgument));
 
    if (_numPrivateStates[0] == 0
    && _numPrivateStates[1] == 0)
      {
    numPrivateStates = _numPrivateStates;
    hasProductStructureData = false;
    return true;
      }
 
    int player, product=1;
    for (player=0; player<numPlayers; player++)
      product*=_numPrivateStates[player];
    if (product!=numStates)
      return false;
  
    numPrivateStates = _numPrivateStates;
    hasProductStructureData = true;
 
    return true;
  }
 
  string getObjLabels(int obj) {
    return objectiveLabels[obj];
  }
 
  vector<string>& getObjLabels() {
    return objectiveLabels;
  }
 
  void setObjLabel(int obj,string label) {
    objectiveLabels[obj] = label;
  }
 
 
  void findLabelRedundancies(int obj);
 
 
  void nameEmptyLabels();
 
  bool hasProductStructure() const { return hasProductStructureData; }
 
  const vector<int> & getNumPrivateStates () const { return numPrivateStates; }
 
  int getNumObjectives() const { return numObjectives; }
  int getNumStates() const { return numStates; }
  const vector<int> & getNumActions() const { return numActions; }
  const vector<int> & getNumTypes() const { return numTypes; }
  int getNumPlayers() const { return numPlayers; }
  
};
 
#endif