bcesolution.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 BCESOLUTION_HPP
#define BCESOLUTION_HPP
 
#include "bcecommon.hpp"
#include "bcegame.hpp"
#include "bceexception.hpp"
#include "bcequilibrium.hpp"
#include "bcecounter.hpp"
 
#include <boost/serialization/list.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/map.hpp>
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/utility.hpp>
 
 
class BCESolution
{
private:
  BCEGame game;
  list<BCEquilibrium> newEquilibria;
  vector<BCEquilibrium> equilibria;
  int currentEquilibrium;
 
  vector<vector<double> > mapBoundaryWeights;
  vector<double> mainObjectiveWeights;
  bool boundaryMapped;
 
public:
  template <class Archive>
  void serialize(Archive& ar, const unsigned int version)
  {
    ar & newEquilibria;
    ar & equilibria;
    ar & game;
    ar & currentEquilibrium;
    ar & mapBoundaryWeights;
    ar & boundaryMapped;
    ar & mainObjectiveWeights;
  }
 
  BCESolution ():currentEquilibrium(0),
         boundaryMapped(false),
         mapBoundaryWeights(2,vector<double>(2,0)),
         mainObjectiveWeights(2,0)
  {}
 
 
  BCESolution (const BCEGame & game);
 
  ~BCESolution () {}
 
  /* Managing the equilibria. */
  void addEquilibrium(const map<int,double> & distr);
  void clearEquilibria();
  void setBoundaryMapped(const bool isMapped) 
  { boundaryMapped = isMapped; }
  void setMapBoundaryWeights(const vector<vector<double> >& weights)
  { mapBoundaryWeights = weights; }
  void setMainObjectiveWeights(const vector<double>& weights) {
    mainObjectiveWeights = weights;
  }
 
  void consolidateEquilibria();
  const BCEGame & getGame() const { return game; }
 
 
  const BCEquilibrium & getEquilibrium(int equilibriumIndex) const;
 
  void setCurrentEquilibrium(int equilibriumIndex);
 
  BCESolution& operator=(const BCESolution &rhs);
 
  /* Statistical routines */
 
  void getExpectedObjectives(vector<double> &objectiveValues) const;
 
  void getExpectedObjectives(vector< vector<double> > &objectiveValues) const;
  void getExpectedObjectives(vector<double> &objectiveValues,
                 const map<int,double> &distribution) const;
 
 
  double getDeviationObjectives(int player, int action, int type,
                vector< vector<double> > & objectiveValues) const;
 
 
  double getConditionalMarginal(const vector<int> &stateConditions, 
                  const vector< vector<int> > &actionConditions,
                  const vector< vector<int> > &typeConditions,
                  bool stateMarginal,
                  const vector<bool> &actionMarginal,
                  const vector<bool> &typeMarginal,
                  vector<double> &distribution) const;
 
  const vector<vector<double> >& getMapBoundaryWeights() const {
    return mapBoundaryWeights;
  }
 
  const vector<double> getMainObjectiveWeights() const {
    return mainObjectiveWeights;
  }
 
  const bool getIsBoundaryMapped() const {
    return boundaryMapped;
  }
 
  static void save(const BCESolution & data, const char* filename)
  {
    ofstream ofs(filename);
 
    if (ofs.good())
      {
    boost::archive::text_oarchive oa(ofs);
    oa << data;
    ofs.close();
      }
    else
      throw(BCEException(BCEException::FailedOpen));
 
  }
 
  static void load(BCESolution & data, const char* filename)
  {
    ifstream ifs(filename);
 
    if (ifs.good())
      {
    boost::archive::text_iarchive ia(ifs);
    ia >> data;
    ifs.close();
      }
    else
      throw(BCEException(BCEException::FailedOpen));
 
  }
 
  friend class boost::serialization::access;
}; // BCESolution
 
#endif