HalfSpace_Rn.h

Go to the documentation of this file.

// politopix allows to make computations on polytopes such as finding vertices, intersecting, Minkowski sums, ...
//     Copyright (C) 2011-2021 : Delos Vincent
//
//     This program is 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.
//
//     This program 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/>.
//
// I2M (UMR CNRS 5295 / University of Bordeaux)
 
#ifndef HALFSPACE_Rn
#define HALFSPACE_Rn
 
#include <vector>
#include <numeric>
#include <stdexcept>
#include <exception>
#include <boost/shared_ptr.hpp>
#include <boost/numeric/ublas/vector.hpp>
#include <boost/numeric/ublas/io.hpp>
#include "Rn.h"
 
class Generator_Rn_SD;
 
using namespace boost::numeric::ublas;
 
 
class polito_EXPORT HalfSpace_Rn {
 
 public:
 
  enum State {
    hs_ON = 0,
    hs_IN = 1,
    hs_OUT = 2,
    hs_UNKNOWN = 3,
    hs_IN_OR_OUT = 4,  // During the truncation process, some generators cannot have the state ON.
    hs_OUT_TO_ON = 5}; // During the truncation process, for convenience, we can shift some generators states from OUT to ON.
 
  HalfSpace_Rn() {}
 
  HalfSpace_Rn(unsigned int n);
 
  virtual ~HalfSpace_Rn() {}
 
  void setCoefficients(const vector<double>& vec) {_coefficients = vec;}
 
  double getCoefficient(unsigned int i) const;
 
   void  setCoefficient(unsigned int i, double c);
 
   void  setConstant(double c) {_constant = c;}
 
  double getConstant() const {return _constant;}
 
  void negate() {_coefficients *= -1.;}
 
  int dimension() const {return _coefficients.size();}
 
  std::string getSideAsText() const {return std::string(">=");}
 
  boost::numeric::ublas::vector<double>::const_iterator begin() const {return _coefficients.begin();}
 
  boost::numeric::ublas::vector<double>::const_iterator  end()  const {return _coefficients.end();}
 
  const boost::numeric::ublas::vector<double>& vect() const {return _coefficients;}
 
  static std::string getStateAsText(const HalfSpace_Rn::State&);
 
  double computeDistancePointHyperplane(const boost::numeric::ublas::vector<double>& thisPoint) const {
    double halfSpaceNorm = std::inner_product(_coefficients.begin(), _coefficients.end(), _coefficients.begin(), 0.);
    halfSpaceNorm = sqrt(halfSpaceNorm);
    double scalarProduct = std::inner_product(thisPoint.begin(), thisPoint.end(), _coefficients.begin(), 0.);
    double distanceToHyperplane = (scalarProduct+_constant) / halfSpaceNorm;
    return distanceToHyperplane;
  }
 
  double computeDistancePointHyperplane(const boost::numeric::ublas::vector<double>& thisPoint, double halfSpaceNorm) const {
    double scalarProduct = std::inner_product(thisPoint.begin(), thisPoint.end(), _coefficients.begin(), 0.);
    double distanceToHyperplane = (scalarProduct+_constant) / halfSpaceNorm;
    return distanceToHyperplane;
  }
 
  double computeDistancePointHyperplane(
      const boost::numeric::ublas::vector<double>& thisPoint, 
      boost::numeric::ublas::vector<double>& projectedPoint, 
      double halfSpaceNorm) const {
    double scalarProduct = std::inner_product(thisPoint.begin(), thisPoint.end(), _coefficients.begin(), 0.);
    double distanceToHyperplane = (scalarProduct+_constant) / halfSpaceNorm;
    projectedPoint = thisPoint - distanceToHyperplane*_coefficients;
    return distanceToHyperplane;
  }
 
  virtual void dump(std::ostream &this_ostream) const {
    this_ostream << "(" << getConstant() << ", ";
    unsigned int RnDIM = _coefficients.size();
    {for (unsigned int ii=0; ii<RnDIM; ++ii) {
      this_ostream << getCoefficient(ii);
      if (ii != RnDIM-1)
        this_ostream << ", ";
    }}
    this_ostream << ")";
  }
 
  void print()  const {
    dump(std::cout);
    std::cout << std::endl;
  }
 
  virtual bool testEmptyness(const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_IN,
                             const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_OUT,
                             const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_ON) {
    //std::cout << "DD" << std::endl;
    return (GN_IN.empty());
  }
 
  virtual bool testEmptyness(unsigned int GN_IN, unsigned int GN_OUT, unsigned int GN_ON) {
    //std::cout << "DD" << std::endl;
    return (GN_IN == 0);
  }
 
  virtual void noGeneratorsOUT(std::vector< boost::shared_ptr<Generator_Rn_SD> >& listOfGeneratorSD,
                             const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_ON) {
    //std::cout << "DD" << std::endl;
  }
 
  //virtual void noGeneratorsOUT(std::vector< std::pair< Generator_Rn_SD, Generator_Rn_SD > >& allNeighbours) {
    //std::cout << "DD" << std::endl;
  //}
    
  virtual void prepareSetOfGenerators(std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_IN, std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_OUT) {
    //std::cout << "DD" << std::endl;
  }
 
 
 protected:
  boost::numeric::ublas::vector<double> _coefficients;
  double _constant;
 
};
 
 
class polito_EXPORT NormedHalfSpace_Rn : public HalfSpace_Rn {
 
 public:
  NormedHalfSpace_Rn(HalfSpace_Rn HS) {
    _coefficients = HS.vect();
    _constant = HS.getConstant();
    double halfSpaceNorm = sqrt(std::inner_product(_coefficients.begin(), _coefficients.end(), _coefficients.begin(), 0.));
    _coefficients = _coefficients / halfSpaceNorm;
    _constant = _constant / halfSpaceNorm;
  }
 
};
 
 
class polito_EXPORT Hyperplane_Rn : public HalfSpace_Rn {
 
 public:
   Hyperplane_Rn(unsigned int n):HalfSpace_Rn(n) {}
 
  virtual ~Hyperplane_Rn() {}
 
  virtual void dump(std::ostream &this_ostream) const {
    this_ostream << "(" << getConstant() << "; ";
    unsigned int RnDIM = _coefficients.size();
    {for (unsigned int ii=0; ii<RnDIM; ++ii) {
      this_ostream << getCoefficient(ii);
      if (ii != RnDIM-1)
        this_ostream << "; ";
    }}
    this_ostream << ")";
  }
 
  virtual bool testEmptyness(const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_IN,
                             const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_OUT,
                             const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_ON) {
    //std::cout << "FlatDD" << std::endl;
    return ((GN_IN.empty() && GN_ON.empty()) || (GN_OUT.empty() && GN_ON.empty()));
  }
 
  virtual bool testEmptyness(unsigned int GN_IN, unsigned int GN_OUT, unsigned int GN_ON) {
    //std::cout << "FlatDD" << std::endl;
    return ((GN_IN==0 && GN_ON==0) || (GN_OUT==0 && GN_ON==0));
  }
 
  virtual void noGeneratorsOUT(std::vector< boost::shared_ptr<Generator_Rn_SD> >& listOfGeneratorSD,
                               const std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_ON) {
    //std::cout << "FlatDD" << std::endl;
    listOfGeneratorSD = GN_ON;
  }
 
  //virtual void noGeneratorsOUT(std::vector< Segment_Rn >& allNeighbours);
 
  virtual void prepareSetOfGenerators(std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_IN, std::vector< boost::shared_ptr<Generator_Rn_SD> >& GN_OUT) {
    //std::cout << "FlatDD" << std::endl;
    GN_OUT.insert(GN_OUT.end(), GN_IN.begin(), GN_IN.end());
    GN_IN.clear();
  }
 
};
 
#endif // HALFSPACE_Rn