EstimateDiameter.hpp

Go to the documentation of this file.

// ========================================================================================
//  ApproxMVBB
//  Copyright (C) 2014 by Gabriel Nützi <nuetzig (at) imes (d0t) mavt (d0t) ethz (døt) ch>
//
//  This Source Code Form is subject to the terms of the Mozilla Public
//  License, v. 2.0. If a copy of the MPL was not distributed with this
//  file, You can obtain one at http://mozilla.org/MPL/2.0/.
// ========================================================================================
#ifndef ApproxMVBB_Diameter_EstimateDiameter_hpp
#define ApproxMVBB_Diameter_EstimateDiameter_hpp

#include "ApproxMVBB/Diameter/TypeSegment.hpp"
#include "ApproxMVBB/RandomGenerators.hpp"

#include <random>

namespace ApproxMVBB{

class APPROXMVBB_EXPORT DiameterEstimator{
    public:

    DiameterEstimator(std::size_t seed = RandomGenerators::defaultSeed) : m_gen(seed) {}

    double estimateDiameter(Diameter::TypeSegment *theDiam,
                          double const**theList,
                          const int first,
                          const int last,
                          const int dim,
                          double epsilon);

    private:

    double estimateDiameterInOneList(Diameter::TypeSegment *theDiam,
                                     double const**theList,
                                     const int first,
                                     const int last,
                                     const int dim,
                                     double _epsilon_ );


    int _verbose_when_reducing_ = 0;
    inline void _VerboseWhenReducing(){ _verbose_when_reducing_ = 1; }
    inline void _NoVerboseWhenReducing(){ _verbose_when_reducing_ = 0;}
    inline int _GetVerboseWhenReducing(){ return _verbose_when_reducing_ ;}


    int _reduction_mode_in_iterative_ = 1;
    inline void _SetReductionModeInIterative( int m )
    {
      switch ( m ) {
      case 0 :
      case 1 :
        _reduction_mode_in_iterative_ = m;
        break;
      case 2 :
      default :
        break;
      }
    }
    inline int _GetReductionModeInIterative(){return _reduction_mode_in_iterative_ ;}

    int _reduction_mode_of_diameter_ = 1;
    inline void _SetReductionModeOfDiameter( int m )
    {
      switch ( m ) {
      case 0 :
      case 1 :
      case 2 :
        _reduction_mode_of_diameter_ = m;
        break;
      default :
        break;
      }
    }
    int _GetReductionModeOfDiameter(){return _reduction_mode_of_diameter_; }

    /* 'reduction' of double normals
     */
    int _reduction_mode_of_dbleNorm_ = 1;
    inline void _SetReductionModeOfDbleNorm( int m )
    {
      switch ( m ) {
      case 0 :
      case 1 :
      case 2 :
        _reduction_mode_of_dbleNorm_ = m;
        break;
      default :
        break;
      }
    }
    inline int _GetReductionModeOfDbleNorm(){return _reduction_mode_of_dbleNorm_ ;}

    /* reduction by processing couple of double normals
     */
    int _try_to_reduce_Q_ = 1;

    inline void _DoTryToReduceQ() { _try_to_reduce_Q_ = 1;}
    inline void _DoNotTryToReduceQ(){ _try_to_reduce_Q_ = 0;}
    inline int _GetTryToReduceQ(){return _try_to_reduce_Q_ ; }


    int _Q_scan_ = 0;
    inline void _SetQscanToForward(){ _Q_scan_ = 1;}
    inline void _SetQscanToBackward(){ _Q_scan_ = 0;}
    inline int _GetQscan(){return _Q_scan_ ;}


    int _tight_bounds_ = 0;
    inline void _DoTryToGetTightBounds(){ _tight_bounds_ = 1;}
    inline void _DoNotTryToGetTightBounds(){ _tight_bounds_ = 0;}
    inline int _GetTightBounds(){ return _tight_bounds_ ; }
    RandomGenerators::DefaultRandomGen m_gen; 
    
    int getRandomInt( unsigned int min, unsigned int max ){
      if ( min <= max ){
        return static_cast<int>(RandomGenerators::DefaultUniformUIntDistribution<unsigned int>{min,max}(m_gen));
      }else{
        return static_cast<int>(RandomGenerators::DefaultUniformUIntDistribution<unsigned int>{max,min}(m_gen));
      }
    }

};
}

#endif