sgiteration_pencilsharpening.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 _SGITERATION_HPP
#define _SGITERATION_HPP
 
#include "sggame.hpp"
#include "sgaction_pencilsharpening.hpp"
#include <boost/archive/text_iarchive.hpp>
#include <boost/archive/text_oarchive.hpp>
#include <boost/serialization/utility.hpp>
 
// Forward declaration of SGApprox
class SGApprox;
 
 
class SGIteration_PencilSharpening
{
private:
  int iteration; 
  int revolution; 
  int numExtremeTuples; 
  SGTuple pivot; 
  SGPoint direction; 
  vector< vector<SGBaseAction> > actions; 
  int bestState; 
  int bestAction; 
  SG::Regime regime; 
  vector<int> actionTuple; 
  vector<SG::Regime> regimeTuple; 
  SGTuple threatTuple;
 
public:
  SGIteration_PencilSharpening() {}
 
  SGIteration_PencilSharpening(const SGApprox & approx,
                            bool storeActions = true);
 
  int getIteration() const { return iteration; } 
  int getRevolution() const { return revolution; }
  int getNumExtremeTuples() const { return numExtremeTuples; }
  const SGTuple & getPivot() const { return pivot; }
  const SGPoint & getDirection() const { return direction; }
  const vector< vector<SGBaseAction> > & getActions() const { return actions; }
  int getBestState() const { return bestState; }
  int getBestAction() const { return bestAction; }
  SG::Regime getRegime() const { return regime; }
  const vector<int> & getActionTuple() const { return actionTuple; }
  const vector<SG::Regime> & getRegimeTuple() const { return regimeTuple; }
  const SGTuple & getThreatTuple() const { return threatTuple; }
  
  friend class boost::serialization::access;
  template<class Archive>
 
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & iteration;
    ar & revolution;
    ar & numExtremeTuples;
    ar & pivot;
    ar & direction;
    ar & actions;
    ar & bestState;
    ar & bestAction;
    ar & regime;
    ar & actionTuple;
    ar & regimeTuple;
    ar & threatTuple;
  }
}; // SGIteration_PencilSharpening
 
#endif