bcecounter.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 BCECOUNTER_HPP
#define BCECOUNTER_HPP
 
#include "bcecommon.hpp"
#include "bceexception.hpp"
 
 
class BCECounter
{
private:
 
  int variable; 
 
  int marginal;
 
  int stateType;
  int numPlayers;
  int state;
  vector<int> actions; 
  vector<int> types; 
 
  int stateIndex; 
 
  vector<int> actionIndices; 
 
  vector<int> typeIndices;
 
 
  int numMarginalVariables; 
 
  int numVariables; 
 
 
  vector<int> stateConditions; 
 
  vector< vector<int> > actionConditions; 
 
  vector< vector<int> > typeConditions; 
 
 
  bool stateMarginal; 
 
  vector<bool> actionMarginal; 
 
  vector<bool> typeMarginal;
  
  int numStates; 
  vector<int> numActions;
  vector<int> numTypes;
 
  vector<int> actionIncrements;
  vector<int> typeIncrements;
  vector<int> actionDecrements;
  vector<int> typeDecrements;
 
  int stateIncrementMarginal;
  vector<int> actionIncrementsMarginal;
  vector<int> typeIncrementsMarginal;
  vector<int> actionDecrementsMarginal;
  vector<int> typeDecrementsMarginal;
 
  vector<int> actionIncrementsStateType;
  vector<int> typeIncrementsStateType;
  vector<int> typeDecrementsStateType;
 
public:
  BCECounter() {}
 
 
  BCECounter(int _numStates,const vector<int> & _numActions, 
         const vector<int> & _numTypes,
         const vector<int> &_stateConditions, 
         const vector< vector<int> > & _actionConditions, 
         const vector< vector<int> > & _typeConditions,
         bool _stateMarginal,
         const vector<bool> & _actionMarginal,
         const vector<bool> & _typeMarginal):
    numPlayers(2),
    numStates(_numStates), numActions(_numActions),
    numTypes(_numTypes), stateConditions(_stateConditions),
    actionConditions(_actionConditions), 
    typeConditions(_typeConditions),
    stateMarginal(_stateMarginal),
    actionMarginal(_actionMarginal),
    typeMarginal(_typeMarginal),
    actions(2,0), types(2,0),
    actionIncrements(2,0), typeIncrements(2,0),
    actionDecrements(2,0), typeDecrements(2,0),
    stateIncrementMarginal(0),
    actionIncrementsMarginal(2,0), typeIncrementsMarginal(2,0),
    actionDecrementsMarginal(2,0), typeDecrementsMarginal(2,0),
    actionIncrementsStateType(2,0), typeIncrementsStateType(2,0),
    typeDecrementsStateType(2,0)
  {
    initialize();
  }
  
 
  void initialize();
 
 
  bool operator++(); 
 
  int getNumMarginal() {return numMarginalVariables;}
  int getVariable() const { return variable; }
  int getMarginal() const { return marginal; }
  int getState() const { return state; }
  const vector<int> & getTypes() const { return types; }
  const vector<int> & getActions() const { return actions; }
  
}; // BCECounter
 
 
#endif