sgtuple.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 _SGTUPLE_HPP
#define _SGTUPLE_HPP
 
#include "sgcommon.hpp"
#include "sgpoint.hpp"
#include "sgexception.hpp"
 
 
class SGPointComparator
{
private:
  double tol; 
public:
  SGPointComparator(double _tol):
    tol(_tol)
  {}
 
  bool operator()(const SGPoint & pnt0, const SGPoint & pnt1) const
  {
    return SGPoint::distance(pnt0,pnt1) < tol;
  }
};
 
class SGTuple
{
private:
  vector<SGPoint> points; 
public:
  SGTuple(int numStates)
  { points = vector<SGPoint> (numStates); }
 
  SGTuple(int _numStates,
      const SGPoint & point)
  { 
    points = vector<SGPoint> (_numStates,point); 
  }
 
  SGTuple() {}
  ~SGTuple() {}
 
 
  SGPoint expectation(const vector<double> & prob) const;
 
 
  double expectation(const vector<double> & prob, int player) const;
 
  SGPoint average() const;
  double average(int player) const;
 
  static double distance(const SGTuple& t0,
             const SGTuple& t1);
 
  bool strictlyLessThan(const SGTuple & tuple, int coordinate) const;
 
  bool anyNaN() const;
  
  void roundTuple(double tol);
 
  double max(int coordinate) const;
  double min(int coordinate) const;
 
  double max(int coordinate, int & index) const;
  double min(int coordinate, int & index) const;
 
  SGPoint max() const;
  SGPoint min() const;
 
 
  void maxmin(int coordinate, 
          double & max, int & maxIndex, 
          double & min,int & minIndex) const;
 
  void push_back(const SGPoint & point);
  void clear();
  void erase(int start, int end);
  void emplace(int location,const SGPoint & point);
  void unique(double tol);
  
  int size() const { return points.size(); }
 
  // Operators
  inline SGPoint& operator[](int state)
  {
    // state = state % points.size(); // Wrap around
    // if(state < 0 || 
    //    state >= points.size())
    //   throw(SGException(SG::OUT_OF_BOUNDS));
    // if (points.size() == 0)
    //   throw(SGException(SG::EMPTY_TUPLE));
 
    return points[state];
  }
 
  inline const SGPoint& operator[](int state) const
  {
    // if (points.size() == 0)
    //   throw(SGException(SG::EMPTY_TUPLE));
    // if(state < 0 || 
    //    state >= points.size())
    //   throw(SGException(SG::OUT_OF_BOUNDS));
    // state = state % points.size(); // Wrap around
 
    return points[state];
  }
 
  SGTuple& operator=(const SGTuple & rhs);
  SGTuple& operator+=(const SGTuple & rhs);
  SGTuple& operator-=(const SGTuple & rhs);
 
  SGTuple& operator+=(const SGPoint & rhs);
 
  SGTuple& operator-=(const SGPoint & rhs);
  SGTuple& operator*=(double d);
  SGTuple& operator/=(double d);
  const SGTuple operator+(const SGTuple & rhs) const;
  const SGTuple operator+(const SGPoint & rhs) const;
  const SGTuple operator-(const SGTuple & rhs) const;
  const SGTuple operator-(const SGPoint & rhs) const;
  friend SGTuple operator*(double d,const SGTuple & point);
  friend SGTuple operator*(const SGTuple & point,double d);
  friend SGTuple operator/(const SGTuple & point,double d);
  friend ostream& operator<<(ostream& out, const SGTuple& rhs);
 
  template<class Archive>
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & points;
  }
 
  friend class boost::serialization::access;
}; // SGTuple
 
#endif