sgpoint.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
 
// Classes for storing data for stochastic games.
// BAB 9-25-2012
#ifndef _SGPOINT_HPP
#define _SGPOINT_HPP
 
#include "sgcommon.hpp"
 
 
class SGPoint
{
protected:
  vector<double> x; 
public:
  SGPoint():  x(2,0.0) {}
  SGPoint(double _x): x(2,_x) {}
  SGPoint(int n): x(n,0) {}
  SGPoint(int n, double _x): x(n,_x) {}
  SGPoint(vector<double> _x)
  {
    x = _x;
  }
  SGPoint(double _x0, double _x1): x(2,0.0)
  { x[0] = _x0; x[1] = _x1;  }
 
  ~SGPoint(){}
 
  int size () const {return x.size();}
  SGPoint getNormal() const;
  double norm() const {return std::sqrt((*this)*(*this));}
  double angle(const SGPoint& base) const;
  static double distance(const SGPoint& p0,
             const SGPoint& p1);
  static SGPoint cross(const SGPoint& p0,
               const SGPoint& p1);
  bool rotateCCW(double pi);
  bool rotateCW(double pi) {return rotateCCW(-pi);}
  bool normalize();
  bool anyNaN() const;
 
  void roundPoint(double tol);
 
  void max(const SGPoint & p);
  void min(const SGPoint & p);
 
  void plusWithWeight(const SGPoint & p,double w);
  
  // Operators
  inline double& operator[](int player)
  {
    // // player = player % x.size(); // Wrap around
    // if(player < 0 || player >= x.size())
    //   throw(SGException(SG::OUT_OF_BOUNDS));
 
    return x[player];
  }
  inline const double& operator[](int player) const
  {
    // // player = player % x.size(); // Wrap around
    // if(player < 0 || player >= x.size())
    //   throw(SGException(SG::OUT_OF_BOUNDS));
 
    return x[player];
  }
  SGPoint& operator=(const SGPoint & rhs);
  SGPoint& operator=(double d);
  SGPoint& operator+=(const SGPoint & rhs);
  SGPoint& operator-=(const SGPoint & rhs);
  SGPoint& operator-=(double d);
  SGPoint& operator*=(double d);
  SGPoint& operator/=(double d);
  const SGPoint operator+(const SGPoint & rhs) const;
  const SGPoint operator-(const SGPoint & rhs) const;
  const SGPoint operator-(double d) const;
  friend SGPoint operator*(double d,const SGPoint & point);
  friend SGPoint operator*(const SGPoint & point,double d);
  friend SGPoint operator/(const SGPoint & point,double d);
  double operator*(const SGPoint & rhs) const; // dot product
  bool operator==(const SGPoint & rhs) const;
  bool operator!=(const SGPoint & rhs) const;
  bool operator>=(const SGPoint & rhs) const;
  bool operator>(const SGPoint & rhs) const;
  bool operator<=(const SGPoint & rhs) const;
  bool operator<(const SGPoint & rhs) const;
  bool operator>=(double rhs) const;
  bool operator>(double rhs) const;
  bool operator<=(double rhs) const;
  bool operator<(double rhs) const;
  friend ostream& operator<<(ostream& out, const SGPoint& rhs);
 
 
  static double invertSystem(SGPoint& x, const SGPoint&b,
                 const SGPoint& a0, const SGPoint& a1);
 
  static double intersectRay(SGPoint& intersection,
                 SGPoint& weights,
                 const SGPoint& pivot,
                 const SGPoint& direction,
                 const SGPoint& t0,
                 const SGPoint& t1);
 
  static double signedArea(const SGPoint& p0,
               const SGPoint& p1,
               const SGPoint& p2);
 
  template<class Archive>
  void serialize(Archive &ar, const unsigned int version)
  {
    ar & x;
  }
 
  friend class boost::serialization::access;
  friend class SGTuple;
}; // SGPoint
 
#endif