gum::credal::LRSWrapper< GUM_SCALAR > Class Template Reference

Class template acting as a wrapper for Lexicographic Reverse Search by David Avis. More...

#include <agrum/CN/LrsWrapper.h>

Collaboration diagram for gum::credal::LRSWrapper< GUM_SCALAR >:

Public Member Functions
Constructors / Destructors
	LRSWrapper ()
	Default Constructor. More...
	~LRSWrapper ()
	Default Destructor. More...
Getters and setters
const matrix &	getInput () const
	Get the intput matrix of the problem. More...
const matrix &	getOutput () const
	Get the output matrix solution of the problem. More...
const unsigned int &	getVerticesNumber () const
	Get the number of vertices of this polytope. More...
const GUM_SCALAR &	getVolume () const
	Get the volume of the polytope that has been computed. More...
setUp / tearDown
void	setUpH (const Size &card)
	Sets up an H-representation. More...
void	setUpV (const Size &card, const Size &vertices)
	Sets up a V-representation. More...
void	tearDown ()
	Reset the wrapper as if it was built. More...
void	nextHInput ()
	Reset the wrapper for next computation for a H-representation with the same variable cardinality and number of inequalities. More...
Input filling methods
void	fillH (const GUM_SCALAR &min, const GUM_SCALAR &max, const Size &modal)
	Creates the H-representation of min <= p(X=modal | .) <= max and add it to the problem input input. More...
void	fillMatrix (const std::vector< std::vector< GUM_SCALAR > > &matrix)
	Fill the H-representation from the matrix given in argument. More...
void	fillV (const std::vector< GUM_SCALAR > &vertex)
	Creates the V-representation of a polytope by adding a vertex to the problem input input. More...
lrs algorithms
void	H2V ()
	H-representation to V-representation. More...
void	V2H ()
	V-representation to H-representation. More...
void	computeVolume ()
	Computes a polytope ( pseudo ) volume from it's V-representation. More...
void	elimRedundVrep ()
	V-Redundancy elimination. More...

Detailed Description

template<typename GUM_SCALAR>
class gum::credal::LRSWrapper< GUM_SCALAR >

Class template acting as a wrapper for Lexicographic Reverse Search by David Avis.

Template Parameters

GUM_SCALAR

A floating type ( float, double, long double ... ).

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN()

Definition at line 106 of file LrsWrapper.h.

Member Typedef Documentation

matrix

template<typename GUM_SCALAR >

using gum::credal::LRSWrapper< GUM_SCALAR >::matrix = typename std::vector< std::vector< GUM_SCALAR > >

private

Shortcut for dynamic matrix using vectors.

Definition at line 109 of file LrsWrapper.h.

Member Enumeration Documentation

_states_

template<typename GUM_SCALAR >

enum gum::credal::LRSWrapper::_states_ : char

strongprivate

The possible states of the LrsWrapper.

Some functions will throw an exception if the state is not correct. It allows the user to avoid making - invisible - mistakes.

Enumerator
none
Hup
Vup
H2Vready
V2Hready

Definition at line 143 of file LrsWrapper.h.

                          : char
      {
        none     = char(0),
        Hup      = char(1),
        Vup      = char(2),
        H2Vready = char(3),
        V2Hready = char(4),
      };

Constructor & Destructor Documentation

LRSWrapper()

template<typename GUM_SCALAR >

gum::credal::LRSWrapper< GUM_SCALAR >::LRSWrapper

(

)

Default Constructor.

Definition at line 31 of file LrsWrapper_tpl.h.

                                         {
      _state_ = _states_::none;

      _vertices_ = 0;
      _card_     = 0;

      _volume_ = 0;

      _getVolume_ = false;
      _hull_      = false;
      _polytope_  = false;

      GUM_CONSTRUCTOR(LRSWrapper);
    }

~LRSWrapper()

template<typename GUM_SCALAR >

gum::credal::LRSWrapper< GUM_SCALAR >::~LRSWrapper

(

)

Default Destructor.

Definition at line 47 of file LrsWrapper_tpl.h.

                                          {
      GUM_DESTRUCTOR(LRSWrapper);
    }

Member Function Documentation

_coutOff_()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::_coutOff_ ( ) const

private

The function that redirects standard cout to /dev/null.

Definition at line 702 of file LrsWrapper_tpl.h.

                                                   {
      fflush(stdout);
#ifdef _MSC_VER
      freopen("NUL", "w", stdout);
#else    // _MSC_VER
      _oldCout_ = dup(1);

      int new_cout = open("/dev/null", O_WRONLY);
      dup2(new_cout, 1);
      close(new_cout);
#endif   // _MSC_VER
    }

_coutOn_()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::_coutOn_ ( ) const

private

The function that restores standard cout.

Definition at line 716 of file LrsWrapper_tpl.h.

                                                  {
      fflush(stdout);
#ifdef _MSC_VER
      freopen("CON", "w", stdout);
#else    // _MSC_VER
      dup2(_oldCout_, 1);
      close(_oldCout_);
#endif   // _MSC_VER
    }

_fill_()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::_fill_ ( ) const

private

Fill lrs_dictionnary and datas from input using integer rationals.

Build polyhedron constraints and objective. Rational< GUM_SCALAR >::continuedFrac is the default algorithm used to approximate reals by integer rationals.

Definition at line 549 of file LrsWrapper_tpl.h.

                                                {
      std::size_t cols = _input_[0].size();

      int64_t* num = new int64_t[cols];   // ISO C++ forbids variable length array,
                                          // we need to do this instead
      int64_t* den = new int64_t[cols];

      int64_t rows = int64_t(_input_.size());

      int64_t numerator, denominator;

      for (int64_t row = 0; row < rows; row++) {
        for (std::size_t col = 0; col < cols; col++) {
          Rational< GUM_SCALAR >::continuedFracFirst(numerator,
                                                     denominator,
                                                     _input_[std::size_t(row)][col]);

          num[col] = numerator;
          den[col] = denominator;
        }

        /* GE is inequality, EQ is equation */
        /* 1L, 0L respectively */
        lrs_set_row(_dic_,
                    _dat_,
                    int64_t(row + 1),
                    num,
                    den,
                    1L);   // do NOT forget this + 1 on row
      }

      delete[] num;
      delete[] den;
    }

_freeLrs_()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::_freeLrs_ ( )

private

Free lrs space.

Definition at line 674 of file LrsWrapper_tpl.h.

                                             {
      /* free space : do not change order of next lines! */

      lrs_clear_mp_vector(_lrsOutput_, _dat_->n);

      if (_dat_->nredundcol > 0) lrs_clear_mp_matrix(_Lin_, _dat_->nredundcol, _dat_->n);

      if (_dat_->runs > 0) {
        free(_dat_->isave);
        free(_dat_->jsave);
      }

      auto savem = _dic_->m; /* need this to clear  _dat_*/

      lrs_free_dic(_dic_, _dat_); /* deallocate lrs_dic */

      _dat_->m = savem;
      lrs_free_dat(_dat_);

      std::string         name = "LrsWrapper:";
      std::vector< char > chars(name.c_str(), name.c_str() + name.size() + 1u);

      lrs_close(&chars[0]);

      //  _coutOn_();
    }

_getLRSWrapperOutput_()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::_getLRSWrapperOutput_ ( lrs_mp  Nin, lrs_mp  Din, std::vector< int64_t > &  Num, std::vector< int64_t > &  Den  ) const

private

Translate a single output from lrs.

Only vertices are supposed to be read at this step.

Parameters

Nin	Input numerators in mp format (returned by lrs).
Din	Input denominators in mp format (returned by lrs).
Num	Output integer numerators.
Den	Output integer denominators.

Definition at line 491 of file LrsWrapper_tpl.h.

                                                                                          {
      int64_t Nsize = (Nin[0] > 0) ? Nin[0] : -Nin[0];
      int64_t Dsize = (Din[0] > 0) ? Din[0] : -Din[0];

      int64_t num = 0L;
      int64_t den = 0L;

      int64_t tmp;

      for (decltype(Nsize) i = Nsize - 1; i > 0; i--) {
        tmp = Nin[i];

        for (decltype(i) j = 1; j < i; j++)
          tmp *= BASE;

        num += tmp;
      }

      if (!(Din[0] == 2L && Din[1] == 1L)) { /* rational */
        for (decltype(Dsize) i = Dsize - 1; i > 0; i--) {
          tmp = Din[i];

          for (decltype(i) j = 1; j < i; j++)
            tmp *= BASE;

          den += tmp;
        }
      } else {
        den = 1L;
      }

      int64_t Nsign = ((Nin[0] < 0) ? -1L : 1L);
      int64_t Dsign = ((Din[0] < 0) ? -1L : 1L);

      if ((Nsign * Dsign) == -1L) num = -num;

      Num.push_back(num);
      Den.push_back(den);
    }

_initLrs_()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::_initLrs_ ( )

private

Initialize lrs structs and first basis according to flags.

Definition at line 585 of file LrsWrapper_tpl.h.

                                             {
      if (_state_ != _states_::H2Vready && _state_ != _states_::V2Hready)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >:: _initLrs_ : not ready, current state "
                  "is still : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);

      // __coutOff();

      std::string         name = "\n*LrsWrapper:";
      std::vector< char > chars(name.c_str(), name.c_str() + name.size() + 1u);
      // use &chars[0] as a char*

      if (!lrs_init(&chars[0])) {
        //  _coutOn_();
        GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : failed lrs_init")
      }

      name  = "LRSWrapper globals";
      chars = std::vector< char >(name.c_str(), name.c_str() + name.size() + 1u);

      _dat_ = lrs_alloc_dat(&chars[0]);

      if (_dat_ == nullptr) {
        //  _coutOn_();
        GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : failed lrs_alloc_dat")
      }

      _dat_->n = Size(_input_[0].size());
      _dat_->m = Size(_input_.size());

      _dat_->getvolume = (_getVolume_) ? 1L : 0L;
      _dat_->hull      = (_hull_) ? 1L : 0L;
      _dat_->polytope  = (_polytope_) ? 1L : 0L;

      _lrsOutput_ = lrs_alloc_mp_vector(_dat_->n);

      _dic_ = lrs_alloc_dic(_dat_);

      if (_dic_ == nullptr) {
        //  _coutOn_();
        GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : failed lrs_alloc_dic")
      }

      _fill_();

      /* Pivot to a starting dictionary */
      if (!lrs_getfirstbasis(&_dic_, _dat_, &_Lin_, 0L)) {
        //  _coutOn_();
        GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : failed lrs_getfirstbasis");
      }

      /* There may have been column redundancy */
      /* If so the linearity space is obtained and redundant */
      /* columns are removed. User can access linearity space */
      /* from lrs_mp_matrix Lin dimensions nredundcol x d+1  */

      decltype(_dat_->nredundcol) startcol = 0;

      if (_dat_->homogeneous && _dat_->hull) {
        startcol++; /* col zero not treated as redundant   */

        if (!_dat_->restart) {
          //  _coutOn_();

          for (decltype(_dat_->nredundcol) col = startcol; col < _dat_->nredundcol; col++)
            lrs_printoutput(_dat_, _Lin_[col]);

          GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : redundant columns !")
        }
      }
      /*
  if (  _dat_->nredundcol > 0 ) {
     _coutOn_();

            for ( decltype(  _dat_->nredundcol ) col = 0, end =
   _dat_->nredundcol;
          col < end;
          col++ )
      lrs_printoutput(  _dat_,  _Lin_[col] );

    GUM_ERROR(
        FatalError,
        "LRSWrapper< GUM_SCALAR >:: _initLrs_ : redundant columns !" );
  }
  */
    }

computeVolume()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::computeVolume

(

)

Computes a polytope ( pseudo ) volume from it's V-representation.

Warning

Volume can only be computed using V-representation. H-representation volume computation is not predictable.

Probabilistic polytopes are not full dimensional : they lie in the simplex' hyper plane, therefor a pseudo-volume will be computed by projecting the polytope. The projection used is the lexicographically smallest coordinate subspace.

Definition at line 364 of file LrsWrapper_tpl.h.

                                                 {
      if (!_state_ == _states_::V2Hready)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::computeVolume : "
                  "volume is only for V-representation or "
                  "fillV has not been called with all "
                  "vertices, current state is still : "
                     << _setUpStateNames_[_state_]);

      //  _coutOff_();

      _getVolume_ = true;

      _initLrs_();

      do {
        for (decltype(_dic_->d) col = 0, end = _dic_->d; col <= end; col++)
          lrs_getsolution(_dic_, _dat_, _lrsOutput_, col);
      } while (lrs_getnextbasis(&_dic_, _dat_, 0L));

      int64_t Nsize = (_dat_->Nvolume[0] > 0) ? _dat_->Nvolume[0] : -_dat_->Nvolume[0];
      int64_t Dsize = (_dat_->Dvolume[0] > 0) ? _dat_->Dvolume[0] : -_dat_->Dvolume[0];

      int64_t num = 0L, den = 0L;
      int64_t tmp;

      for (decltype(Nsize) i = Nsize - 1; i > 0; i--) {
        tmp = _dat_->Nvolume[i];

        for (decltype(i) j = 1; j < i; j++)
          tmp *= BASE;

        num += tmp;
      }

      for (decltype(Dsize) i = Dsize - 1; i > 0; i--) {
        tmp = _dat_->Dvolume[i];

        for (decltype(i) j = 1; j < i; j++)
          tmp *= BASE;

        den += tmp;
      }

      _volume_ = num * 1.0 / den;

      _freeLrs_();

      //  _coutOn_();
    }

elimRedundVrep()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::elimRedundVrep

(

)

V-Redundancy elimination.

Eliminates redundant vertices from a polytope V-representation input input.

Definition at line 416 of file LrsWrapper_tpl.h.

                                                  {
      if (_state_ != _states_::V2Hready)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::elimRedundVrep : only for "
                  "V-representation or fillV has not been called with all vertices, "
                  "current state is still : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);

      //  _coutOff_();

      _initLrs_();

      int64_t* redineq; /* redineq[i]=0 if ineq i non-red,1 if red,2 linearity  */

      /*********************************************************************************/
      /* Test each row of the dictionary to see if it is redundant */
      /*********************************************************************************/

      /* note some of these may have been changed in getting initial dictionary
       */
      auto m = _dic_->m_A;
      auto d = _dic_->d;
      /* number of linearities in input */ /* should be 0 ! */
      auto nlinearity = _dat_->nlinearity;
      auto lastdv     = _dat_->lastdv;

      /* linearities are not considered for redundancy */
      redineq = (int64_t*)calloc(std::size_t(m + 1), sizeof(int64_t));

      for (decltype(nlinearity) i = 0; i < nlinearity; i++)
        redineq[_dat_->linearity[i]] = 2L;

      /* rows 0..lastdv are cost, decision variables, or linearities  */
      /* other rows need to be tested                                */

      for (decltype(m + d) index = lastdv + 1, end = m + d; index <= end; index++) {
        /* input inequality number of current index             */
        auto ineq = _dat_->inequality[index - lastdv]; /* the input inequality number
                                                         corr. to this index */

        redineq[ineq] = checkindex(_dic_, _dat_, index);
      }

      /* linearities */
      if (nlinearity > 0)
        GUM_ERROR(FatalError,
                  "LRSWrapper< GUM_SCALAR >::elimRedundVrep : not "
                  "reading a vertex but a linearity !");

      /* count number of non-redundant inequalities */
      /*
      auto nredund = nlinearity;
      for ( decltype ( m ) i = 1; i <= m; i++ )
        if ( redineq[ i ] == 0 )
          nredund++;
      */

      // __vertices = nredund;
      // __output = std::vector< std::vector< GUM_SCALAR > > ( nredund,
      // std::vector<
      // GUM_SCALAR > (  _dat_->n - 1 ) );

      for (decltype(m) i = 1; i <= m; i++)
        if (redineq[i] == 0)
          _output_.push_back(std::vector< GUM_SCALAR >(++_input_[std::size_t(i - 1)].begin(),
                                                       _input_[std::size_t(i - 1)].end()));

      _vertices_ = (unsigned int)_output_.size();

      _freeLrs_();

      //  _coutOn_();
    }

fillH()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::fillH	(	const GUM_SCALAR &	min,
		const GUM_SCALAR &	max,
		const Size &	modal
	)

Creates the H-representation of min <= p(X=modal | .) <= max and add it to the problem input input.

Parameters

min	The lower value of p(X=modal | .).
max	The upper value of p(X=modal | .).
modal	The modality on which we put constraints.

Definition at line 182 of file LrsWrapper_tpl.h.

                                                                  {
      if (_state_ != _states_::Hup)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::fillH : setUpH or nextInput has not "
                  "been called or H-representation is complete, current state is : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);

      if (modal >= _card_)
        GUM_ERROR(OutOfBounds,
                  "LRSWrapper< GUM_SCALAR >::fillH : modality is "
                  "greater or equal than cardinality : "
                     << modal << " >= " << _card_);

      _input_[modal * 2][0]         = -min;
      _input_[modal * 2][modal + 1] = 1;

      _input_[modal * 2 + 1][0]         = max;
      _input_[modal * 2 + 1][modal + 1] = -1;

      _vertex_[modal] = max;

      _insertedModals_.insert(int(modal));

      if (_insertedModals_.size() == _card_) _state_ = _states_::H2Vready;
    }

fillMatrix()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::fillMatrix

(

const std::vector< std::vector< GUM_SCALAR > > &

matrix

)

Fill the H-representation from the matrix given in argument.

Parameters

matrix

The H-representation of the polytope of the form 0 <= -b Ax, A is the matrix, each column the coefficient of the variable in x.

Definition at line 211 of file LrsWrapper_tpl.h.

                                                           {
      if (_state_ != _states_::Hup)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::fillH : setUpH or nextInput has not "
                  "been called or H-representation is complete, current state is : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);

      if (matrix[0].size() - 1 != _card_)
        GUM_ERROR(OutOfBounds,
                  "LRSWrapper< GUM_SCALAR >::fillMatrix : size is "
                  "different than cardinality : "
                     << (matrix[0].size() - 1) << " != " << _card_);

      _input_ = matrix;

      for (unsigned int modal = 0; modal < _card_; modal++) {
        _insertedModals_.insert(modal);
      }

      _state_ = _states_::H2Vready;
    }

fillV()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::fillV

(

const std::vector< GUM_SCALAR > &

vertex

)

Creates the V-representation of a polytope by adding a vertex to the problem input input.

Parameters

vertex

The vertex we wish to add to the V-representation of the polytope.

Definition at line 235 of file LrsWrapper_tpl.h.

                                                                              {
      if (_state_ != _states_::Vup)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::fillV : setUpV or nextInput has not "
                  "been called or V-representation is complete, current state is : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);

      if (_insertedVertices_.size() == _vertices_)
        GUM_ERROR(OutOfBounds,
                  "LRSWrapper< GUM_SCALAR >::fillV : input is already full with " << _vertices_
                                                                                  << " vertices.");

      bool eq = true;

      for (const auto& v: _insertedVertices_) {
        eq = true;

        for (decltype(_card_) mod = 0; mod < _card_; mod++)
          if (std::fabs(v[mod] - vertex[mod]) > 1e-6) {
            eq = false;
            break;
          }

        if (eq) {
          _vertices_--;
          return;
          // GUM_ERROR ( DuplicateElement, "LRSWrapper< GUM_SCALAR >::fillV :
          // vertex
          // already present : " << vertex );
        }
      }

      auto row = _insertedVertices_.size();

      for (decltype(_card_) mod = 0; mod < _card_; mod++)
        _input_[row][mod + 1] = vertex[mod];

      _insertedVertices_.push_back(vertex);

      if (_insertedVertices_.size() == _vertices_) _state_ = _states_::V2Hready;
    }

getInput()

template<typename GUM_SCALAR >

auto gum::credal::LRSWrapper< GUM_SCALAR >::getInput

(

)

const

Get the intput matrix of the problem.

Returns

A constant reference to the intput matrix.

Definition at line 52 of file LrsWrapper_tpl.h.

                                                                   {
      return _input_;
    }

getOutput()

template<typename GUM_SCALAR >

auto gum::credal::LRSWrapper< GUM_SCALAR >::getOutput

(

)

const

Get the output matrix solution of the problem.

Returns

A constant reference to the output matrix.

Definition at line 57 of file LrsWrapper_tpl.h.

                                                                    {
      return _output_;
    }

getVerticesNumber()

template<typename GUM_SCALAR >

const unsigned int & gum::credal::LRSWrapper< GUM_SCALAR >::getVerticesNumber

(

)

const

Get the number of vertices of this polytope.

Returns

A constant reference to the number of vertices vertices.

Definition at line 62 of file LrsWrapper_tpl.h.

                                                                          {
      return _vertices_;
    }

getVolume()

template<typename GUM_SCALAR >

const GUM_SCALAR & gum::credal::LRSWrapper< GUM_SCALAR >::getVolume

(

)

const

Get the volume of the polytope that has been computed.

Warning

Volume can only be computed using V-representation. H-representation volume computation is not predictable.

Probabilistic polytopes are not full dimensional : they lie in the simplex' hyper plane, therefor a pseudo-volume will be computed by projecting the polytope. The projection used is the lexicographically smallest coordinate subspace.

Returns

A constant reference to the polytope volume.

Definition at line 67 of file LrsWrapper_tpl.h.

                                                                {
      if (_volume_ != 0)
        return _volume_;
      else
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::getVolume () : "
                  "volume computation was not asked for this "
                  "credal set, call computeVolume() from a "
                  "V-representation.");
    }

H2V()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::H2V

(

)

H-representation to V-representation.

Computes the V-representation of a polytope, i.e. it's vertices, from it's H-representation, i.e. the hyper-plan inequalities.

Definition at line 278 of file LrsWrapper_tpl.h.

                                       {
      if (_state_ != _states_::H2Vready)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::H2V : fillH has not been called with "
                  "all modalities, current state is still : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);

      // check that we have a credal set and not a precise point probability,
      // i.e.
      // sum of vertex elements is close to one ( floating type precision )
      GUM_SCALAR sum = 0;

      for (const auto elem: _vertex_)
        sum += elem;

      if (std::fabs(sum - 1) < 1e-6) {
        _output_ = std::vector< std::vector< GUM_SCALAR > >(1, _vertex_);
        return;
      }

      // not precise point probability, initialize lrs

      //  _coutOff_();

      _initLrs_();

      /* We initiate reverse search from this dictionary       */
      /* getting new dictionaries until the search is complete */
      /* User can access each output line from output which is */
      /* vertex/ray/facet from the lrs_mp_vector output         */
      /* prune is TRUE if tree should be pruned at current node */

      // pruning is not used

      std::vector< int64_t > Num; /* numerators of all vertices */
      std::vector< int64_t > Den; /* denominators of all vertices */

      do {
        for (decltype(_dic_->d) col = 0, end = _dic_->d; col <= end; col++)
          if (lrs_getsolution(_dic_, _dat_, _lrsOutput_, col)) {
            // iszero macro could be used here for the test on right
            if (_dat_->hull
                || ((((_lrsOutput_[0])[0] == 2 || (_lrsOutput_[0])[0] == -2)
                     && (_lrsOutput_[0])[1] == 0)
                       ? 1L
                       : 0L)) {
              //  _coutOn_();
              /*for ( decltype(Q->n) i = 0; i < Q->n; i++ )
                pmp ("", output[i]);*/
              GUM_ERROR(FatalError,
                        "LRSWrapper< GUM_SCALAR >::H2V : asked for "
                        "Q-hull computation or not reading a vertex !");
            } else
              for (decltype(_dat_->n) i = 1, end = _dat_->n; i < end; i++)
                _getLRSWrapperOutput_(_lrsOutput_[i], _lrsOutput_[0], Num, Den);
          }
      } while (lrs_getnextbasis(&_dic_, _dat_, 0L));

      auto                      vtx = Num.size();
      std::vector< GUM_SCALAR > vertex(_card_);

      for (decltype(vtx) i = 1; i <= vtx; i++) {
        vertex[(i - 1) % _card_] = GUM_SCALAR(Num[i - 1] * 1.0 / Den[i - 1]);

        if (i % _card_ == 0) {
          _output_.push_back(vertex);
          _vertices_++;
        }
      }

      _freeLrs_();

      //  _coutOn_();
    }

nextHInput()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::nextHInput

(

)

Reset the wrapper for next computation for a H-representation with the same variable cardinality and number of inequalities.

Usefull when creating credal networks specified as intervals over modalities.

Reset wrapper state state to it's previous state and clear output matrix output. Keeps the cardinality card of the variable and therefor the input matrix intput structure.

Definition at line 151 of file LrsWrapper_tpl.h.

                                              {
      _insertedModals_.clear();
      _insertedVertices_.clear();
      _output_.clear();
      _vertex_.clear();
      _vertex_.resize(_card_, 0);

      _volume_   = 0;
      _vertices_ = 0;

      _getVolume_ = false;
      _hull_      = false;
      _polytope_  = false;

      if (_state_ == _states_::H2Vready)
        _state_ = _states_::Hup;
      else if (_state_ == _states_::V2Hready) {
        _state_ = _states_::Vup;
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::nextHInput : only for H-representation "
                  "as input. Previous state was : "
                     << _setUpStateNames_[static_cast< int >(_state_)]);
      } else {
        _input_.clear();
        _state_ = _states_::none;
        _card_  = 0;
        _vertex_.clear();
      }
    }

setUpH()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::setUpH

(

const Size &

card

)

Sets up an H-representation.

Initialize input matrix input to correct dimensions and wrapper state state to states::Hup.

Parameters

card	A constant reference to the cardinality of the variable.

Definition at line 79 of file LrsWrapper_tpl.h.

                                                          {
      if (card < 2)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::setUpH : "
                  "cardinality must be at least 2");

      tearDown();

      _input_ = std::vector< std::vector< GUM_SCALAR > >(card * 2 + 2,
                                                         std::vector< GUM_SCALAR >(card + 1, 0));

      _input_[card * 2]    = std::vector< GUM_SCALAR >(card + 1, -1);
      _input_[card * 2][0] = 1;

      _input_[card * 2 + 1]    = std::vector< GUM_SCALAR >(card + 1, 1);
      _input_[card * 2 + 1][0] = -1;

      _output_ = std::vector< std::vector< GUM_SCALAR > >();

      _vertex_ = std::vector< GUM_SCALAR >(card);

      _state_ = _states_::Hup;

      _card_ = (unsigned int)card;
    }

setUpV()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::setUpV	(	const Size &	card,
		const Size &	vertices
	)

Sets up a V-representation.

Initialize input matrix input to correct dimensions and wrapper state state to states::Vup.

Parameters

card	A constant reference to the cardinality of the variable.
vertices	A constant reference to the number of vertices of the polytope.

Definition at line 106 of file LrsWrapper_tpl.h.

                                                                                {
      if (card < 2)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::setUpV : "
                  "cardinality must be at least 2");

      if (vertices < 2)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::setUpV : vertices "
                  "must be at least 2 to build a polytope");

      tearDown();

      _input_ = std::vector< std::vector< GUM_SCALAR > >(vertices,
                                                         std::vector< GUM_SCALAR >(card + 1, 1));

      _output_ = std::vector< std::vector< GUM_SCALAR > >();

      _state_ = _states_::Vup;

      _card_     = (unsigned int)card;
      _vertices_ = (unsigned int)vertices;
    }

tearDown()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::tearDown

(

)

Reset the wrapper as if it was built.

Reset wrapper state state to states::none and clear all member datas.

Definition at line 131 of file LrsWrapper_tpl.h.

                                            {
      _input_.clear();
      _output_.clear();
      _vertex_.clear();
      _insertedModals_.clear();

      _insertedVertices_.clear();
      _vertices_ = 0;

      _volume_ = 0;

      _state_ = _states_::none;
      _card_  = 0;

      _getVolume_ = false;
      _hull_      = false;
      _polytope_  = false;
    }

V2H()

template<typename GUM_SCALAR >

void gum::credal::LRSWrapper< GUM_SCALAR >::V2H

(

)

V-representation to H-representation.

Warning

Not complete yet.

Computes the H-representation of a polytope from it's V-representation.

Definition at line 354 of file LrsWrapper_tpl.h.

                                       {
      if (!_state_ == _states_::V2Hready)
        GUM_ERROR(OperationNotAllowed,
                  "LRSWrapper< GUM_SCALAR >::V2H : fillV has "
                  "not been called with all vertices, current "
                  "state is still : "
                     << _setUpStateNames_[_state_]);
    }

Member Data Documentation

_card_

template<typename GUM_SCALAR >

unsigned int gum::credal::LRSWrapper< GUM_SCALAR >::_card_

private

Cardinality of the variable.

Definition at line 120 of file LrsWrapper.h.

_dat_

template<typename GUM_SCALAR >

lrs_dat* gum::credal::LRSWrapper< GUM_SCALAR >::_dat_

private

Structure for holding static problem data of lrs.

Definition at line 185 of file LrsWrapper.h.

_dic_

template<typename GUM_SCALAR >

lrs_dic* gum::credal::LRSWrapper< GUM_SCALAR >::_dic_

private

Structure for holding current dictionary and indices of lrs.

Definition at line 182 of file LrsWrapper.h.

_getVolume_

template<typename GUM_SCALAR >

bool gum::credal::LRSWrapper< GUM_SCALAR >::_getVolume_

private

Definition at line 200 of file LrsWrapper.h.

_hull_

template<typename GUM_SCALAR >

bool gum::credal::LRSWrapper< GUM_SCALAR >::_hull_

private

Definition at line 202 of file LrsWrapper.h.

_input_

template<typename GUM_SCALAR >

matrix gum::credal::LRSWrapper< GUM_SCALAR >::_input_

private

Input matrix - either a V-representation or an H-representation.

Definition at line 113 of file LrsWrapper.h.

_insertedModals_

template<typename GUM_SCALAR >

std::unordered_set< int > gum::credal::LRSWrapper< GUM_SCALAR >::_insertedModals_

private

To keep track of which constraints over modalities have been inserted.

When the set is full, the state changes from up to ready.

Definition at line 124 of file LrsWrapper.h.

_insertedVertices_

template<typename GUM_SCALAR >

std::vector< std::vector< GUM_SCALAR > > gum::credal::LRSWrapper< GUM_SCALAR >::_insertedVertices_

private

To keep track of inserted vertices and total.

When set is full, the state changes from up to ready.

Definition at line 132 of file LrsWrapper.h.

_Lin_

template<typename GUM_SCALAR >

lrs_mp_matrix gum::credal::LRSWrapper< GUM_SCALAR >::_Lin_

private

Holds lrs input linearities if any are found.

Definition at line 193 of file LrsWrapper.h.

_lrsOutput_

template<typename GUM_SCALAR >

lrs_mp_vector gum::credal::LRSWrapper< GUM_SCALAR >::_lrsOutput_

private

One line of output of lrs : aither a ray, a vertex, a facet or a linearity.

Definition at line 190 of file LrsWrapper.h.

_oldCout_

template<typename GUM_SCALAR >

int gum::credal::LRSWrapper< GUM_SCALAR >::_oldCout_

mutableprivate

File descriptor of standard cout.

Lrs writes a lot of stuff on standard cout. oldCout is used to save the current cout before redirecting it to /dev/null when calling lrs. The standard cout is restored when lrs is done.

Definition at line 176 of file LrsWrapper.h.

_output_

template<typename GUM_SCALAR >

matrix gum::credal::LRSWrapper< GUM_SCALAR >::_output_

private

Output matrix - either a V-representation or an H-representation.

Definition at line 117 of file LrsWrapper.h.

_polytope_

template<typename GUM_SCALAR >

bool gum::credal::LRSWrapper< GUM_SCALAR >::_polytope_

private

Definition at line 204 of file LrsWrapper.h.

_setUpStateNames_

template<typename GUM_SCALAR >

const char* gum::credal::LRSWrapper< GUM_SCALAR >::_setUpStateNames_[5]

private

Initial value:

= {
         enumStringify(_states_::none),
         enumStringify(_states_::nHup),
         enumStringify(_states_::nVup),
         enumStringify(_states_::nH2Vready),
         enumStringify(_states_::nV2Hready),
      }

To print an enum field name instead of it's value.

Used with GUM_ERROR.

Definition at line 160 of file LrsWrapper.h.

_state_

template<typename GUM_SCALAR >

_states_ gum::credal::LRSWrapper< GUM_SCALAR >::_state_

private

The current state of the LrsWrapper.

Definition at line 153 of file LrsWrapper.h.

_vertex_

template<typename GUM_SCALAR >

std::vector< GUM_SCALAR > gum::credal::LRSWrapper< GUM_SCALAR >::_vertex_

private

In case we have lower = upper for all modalities, a point probability, there is no need to use lrs.

Definition at line 136 of file LrsWrapper.h.

_vertices_

template<typename GUM_SCALAR >

unsigned int gum::credal::LRSWrapper< GUM_SCALAR >::_vertices_

private

The number of vertices of the polytope.

Definition at line 127 of file LrsWrapper.h.

_volume_

template<typename GUM_SCALAR >

GUM_SCALAR gum::credal::LRSWrapper< GUM_SCALAR >::_volume_

private

The volume of the polytope, if computed, 0 otherwise.

Definition at line 156 of file LrsWrapper.h.

---

The documentation for this class was generated from the following files:

• agrum/CN/polytope/LrsWrapper.h
• agrum/CN/polytope/LrsWrapper_tpl.h