GeometricObjectIterator_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) 2012-2015 : 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 GEOMETRIC_OBJECT_ITERATOR_Rn
#define GEOMETRIC_OBJECT_ITERATOR_Rn
 
#include <boost/numeric/ublas/io.hpp>
#include <boost/shared_ptr.hpp>
#include <stdexcept>
#include <exception>
#include <vector>
#include <stack>
#include <set>
#include "Generator_Rn.h"
#include "HalfSpace_Rn.h"
#include "Rn.h"
 
using namespace boost::numeric::ublas;
 
 
template< class GEOMETRIC_OBJECT > class listOfGeometricObjects {
 
 public:
  listOfGeometricObjects() {}
 
  void push_back(const GEOMETRIC_OBJECT& gn) {_GO.push_back(gn);}
 
  const GEOMETRIC_OBJECT& operator [](unsigned int i) const {return _GO[i];}
 
  void operator=(const listOfGeometricObjects< GEOMETRIC_OBJECT >& listOfGN)
  {_GO.clear(); _GO = listOfGN._GO;}
 
  void assign(const listOfGeometricObjects< GEOMETRIC_OBJECT >& listOfGN)
  {_GO.clear(); _GO = listOfGN._GO;}
 
  bool empty() const {return _GO.empty();}
 
  unsigned int size() const {return _GO.size();}
 
  void clear() {_GO.clear();}
 
  void negate() {
    for (typename std::vector< GEOMETRIC_OBJECT >::iterator it=_GO.begin(); it!=_GO.end(); ++it)
      (*it)->negate();
  }
 
  unsigned int find(const GEOMETRIC_OBJECT& GO) const {
    unsigned int index=0;
    typename std::vector< GEOMETRIC_OBJECT >::const_iterator it;
    for (it=_GO.begin(); it!=_GO.end() && *it!=GO; ++it)
      index++;
    if (it == _GO.end()) {
      std::ostringstream stream_;
      stream_ << "listOfGeometricObjects::find() The current object is not stored in array";
      std::string valString = stream_.str();
      throw std::out_of_range(valString);
    }
    return index;
  }
 
  void removeGeometricObjects(const std::set< GEOMETRIC_OBJECT >& setToRemove) {
    for (typename std::vector< GEOMETRIC_OBJECT >::iterator it=_GO.begin(); it!=_GO.end(); ) {
      if (setToRemove.find(*it) != setToRemove.end())
        it = _GO.erase(it);
      else
        ++it;
    }
  }
 
  void removeGeometricObject(unsigned int j) {_GO.erase(_GO.begin()+j);}
 
  static bool inferior(const GEOMETRIC_OBJECT& HS1, const GEOMETRIC_OBJECT& HS2) {
    unsigned int i=0;
    unsigned int n=HS1->dimension();
    do {
      if (HS1->getCoefficient(i) < HS2->getCoefficient(i))
        return true;
      else if (HS1->getCoefficient(i) > HS2->getCoefficient(i))
        return false;
      else
        i++;
    } while (i < n);
    return true;
  }
 
  static bool superior(const GEOMETRIC_OBJECT& HS1, const GEOMETRIC_OBJECT& HS2) {
    return !inferior(HS1, HS2);
  }
 
  void lexminSort(unsigned int step) {
    typename std::vector< GEOMETRIC_OBJECT >::iterator it = _GO.begin();
    std::advance(it, step);
    std::sort( it, _GO.end(), &inferior );
  }
 
  void lexmaxSort(unsigned int step) {
    typename std::vector< GEOMETRIC_OBJECT >::iterator it = _GO.begin();
    std::advance(it, step);
    std::sort( it, _GO.end(), &superior );
  }
 
 protected:
  std::vector< GEOMETRIC_OBJECT > _GO;
};
 
 
template< class GEOMETRIC_OBJECT > class constIteratorOfListOfGeometricObjects {
 
 public:
  constIteratorOfListOfGeometricObjects(const listOfGeometricObjects<GEOMETRIC_OBJECT>& l):_list(l)
  {_iterator=0;_step=0;}
 
  void begin() {_iterator=_step;}
 
  void next() {_iterator++;}
 
  void setStep(unsigned int n) {_step=n; advance(n);}
 
  unsigned int size() const {return _list.size();}
 
  void advance(unsigned int n) {
    if (n > _list.size()) return;
    _iterator = _iterator+n;
    //while (_iterator < _list._fullSize && counter < n) {
      //_iterator++;
      //if (_list._activeFacets[_iterator] == true) {
        //counter++;
      //}
    //}
  }
 
  bool end() const {return (_iterator==_list.size());}
 
  const GEOMETRIC_OBJECT current() {
    if (_iterator < _list.size())
      return _list[_iterator];
    else
      return GEOMETRIC_OBJECT();
  }
 
  void swapElements(unsigned int ind1, unsigned int ind2) {
    GEOMETRIC_OBJECT el1 = _list[ind1];
    _list[ind1] = _list[ind2];
    _list[ind2] = el1;
  }
 
  int currentIteratorNumber() const {return _iterator;}
 
 protected:
  unsigned int _iterator;
  const listOfGeometricObjects<GEOMETRIC_OBJECT>& _list;
  unsigned int _step;
};
 
template< class GEOMETRIC_OBJECT > class lexIteratorOfListOfGeometricObjects {
 
 public:
  lexIteratorOfListOfGeometricObjects(listOfGeometricObjects<GEOMETRIC_OBJECT>& l):
    _iterator(0),_list(l),_alreadySorted(false),_step(0)
    {}
 
  void begin() {_iterator=_step;}
 
  void next() {_iterator++;}
 
  void setStep(unsigned int n) {_step=n;}
 
  bool end() const {return (_iterator==_list.size());}
 
  const GEOMETRIC_OBJECT current() {
    if (_iterator < _list.size())
      return _list[_iterator];
    else
      return GEOMETRIC_OBJECT();
  }
 
  int currentIteratorNumber() const {return _iterator;}
 
 protected:
  unsigned int _iterator;
  listOfGeometricObjects<GEOMETRIC_OBJECT>& _list;
  bool _alreadySorted;
  unsigned int _step;
 
};
 
template< class GEOMETRIC_OBJECT > class lexminIteratorOfListOfGeometricObjects :
  public lexIteratorOfListOfGeometricObjects< GEOMETRIC_OBJECT > {
 
 public:
  lexminIteratorOfListOfGeometricObjects(listOfGeometricObjects<GEOMETRIC_OBJECT>& l):
    lexIteratorOfListOfGeometricObjects< GEOMETRIC_OBJECT >(l) {}
 
  void setStep(unsigned int n) {
    this->_step = n;
    this->_iterator = 0;
    if (this->_alreadySorted == false) {
      this->_list.lexminSort(this->_step);
      this->_alreadySorted = true;
    }
    this->_iterator = this->_step;
  }
 
  void begin() {this->_iterator = this->_step;}
 
};
 
template< class GEOMETRIC_OBJECT > class lexmaxIteratorOfListOfGeometricObjects :
    public lexIteratorOfListOfGeometricObjects< GEOMETRIC_OBJECT > {
 
 public:
  lexmaxIteratorOfListOfGeometricObjects(listOfGeometricObjects<GEOMETRIC_OBJECT>& l):
    lexIteratorOfListOfGeometricObjects< GEOMETRIC_OBJECT >(l) {}
 
  void setStep(unsigned int n) {
    this->_step = n;
    this->_iterator = 0;
    if (this->_alreadySorted == false) {
      this->_list.lexmaxSort(this->_step);
      this->_alreadySorted = true;
    }
    this->_iterator = this->_step;
  }
 
  void begin() {this->_iterator = this->_step;}
 
};
 
 
#endif // GEOMETRIC_OBJECT_ITERATOR_Rn