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

Private Types
enum class	_states_ : char { none = char(0) , Hup = char(1) , Vup = char(2) , H2Vready = char(3) , V2Hready = char(4) }
	The possible states of the LrsWrapper. More...
using	matrix = typename std::vector< std::vector< GUM_SCALAR > >
	Shortcut for dynamic matrix using vectors.

Private Member Functions
lrs datas <-> wrapper datas
void	_freeLrs_ ()
	Free lrs space.
void	_initLrs_ ()
	Initialize lrs structs and first basis according to flags.
void	_fill_ () const
	Fill lrs_dictionnary and datas from `_input_` using integer rationals.
void	_getLRSWrapperOutput_ (lrs_mp Nin, lrs_mp Din, std::vector< int64_t > &Num, std::vector< int64_t > &Den) const
	Translate a single output from lrs.

Private Attributes
matrix	_input_
	Input matrix - either a V-representation or an H-representation.
matrix	_output_
	Output matrix - either a V-representation or an H-representation.
unsigned int	_card_
	Cardinality of the variable.
std::unordered_set< int >	_insertedModals_
	To keep track of which constraints over modalities have been inserted.
unsigned int	_vertices_
	The number of vertices of the polytope.
std::vector< std::vector< GUM_SCALAR > >	_insertedVertices_
	To keep track of inserted vertices and total.
std::vector< GUM_SCALAR >	_vertex_
	In case we have lower = upper for all modalities, a point probability, there is no need to use lrs.
_states_	_state_
	The current state of the LrsWrapper.
GUM_SCALAR	_volume_
	The volume of the polytope, if computed, 0 otherwise.
const char *	_setUpStateNames_ [5]
	To print an enum field name instead of it's value.
int	_oldCout_
	File descriptor of standard cout.
lrs structs
lrs_dic *	_dic_
	Structure for holding current dictionary and indices of lrs.
lrs_dat *	_dat_
	Structure for holding static problem data of lrs.
lrs_mp_vector	_lrsOutput_
	One line of output of lrs : aither a ray, a vertex, a facet or a linearity.
lrs_mp_matrix	_Lin_
	Holds lrs input linearities if any are found.
flags
bool	_getVolume_
bool	_hull_
bool	_polytope_

Detailed Description

template<GUM_Numeric 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(_at_LIP6)

Definition at line 121 of file LrsWrapper.h.

Member Typedef Documentation

◆ matrix

template<GUM_Numeric 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 123 of file LrsWrapper.h.

Member Enumeration Documentation

◆ _states_

template<GUM_Numeric GUM_SCALAR>

enum class 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 157 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<GUM_Numeric GUM_SCALAR>

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

Default Constructor.

Definition at line 56 of file LrsWrapper_tpl.h.

                                         {
      _state_ = _states_::none;
 
      _vertices_ = 0;
      _card_     = 0;
 
      _volume_ = 0;
 
      _getVolume_ = false;
      _hull_      = false;
      _polytope_  = false;
 
      GUM_CONSTRUCTOR(LRSWrapper);
    }

References LRSWrapper(), _card_, _getVolume_, _hull_, _polytope_, _state_, _vertices_, _volume_, and none.

Referenced by LRSWrapper(), and ~LRSWrapper().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ~LRSWrapper()

template<GUM_Numeric GUM_SCALAR>

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

Default Destructor.

Definition at line 72 of file LrsWrapper_tpl.h.

                                          {
      GUM_DESTRUCTOR(LRSWrapper);
    }

References LRSWrapper().

Here is the call graph for this function:

Member Function Documentation

◆ _fill_()

template<GUM_Numeric 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 557 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;
    }

References _dat_, _dic_, _input_, and gum::Rational< GUM_SCALAR >::continuedFracFirst().

Referenced by _initLrs_().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ _freeLrs_()

template<GUM_Numeric GUM_SCALAR>

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

private

Free lrs space.

Definition at line 659 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]);
    }

References _dat_, _dic_, _Lin_, and _lrsOutput_.

Referenced by computeVolume(), elimRedundVrep(), and H2V().

Here is the caller graph for this function:

◆ _getLRSWrapperOutput_()

template<GUM_Numeric 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 499 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);
    }

References BASE.

Referenced by H2V().

Here is the caller graph for this function:

◆ _initLrs_()

template<GUM_Numeric GUM_SCALAR>

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

private

Initialize lrs structs and first basis according to flags.

Definition at line 593 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_)]);
 
      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])) {
        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) {
        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) {
        GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : failed lrs_alloc_dic")
      }
 
      _fill_();
 
      /* Pivot to a starting dictionary */
      if (!lrs_getfirstbasis(&_dic_, _dat_, &_Lin_, 0L)) {
        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) {
          for (decltype(_dat_->nredundcol) col = startcol; col < _dat_->nredundcol; col++)
            lrs_printoutput(_dat_, _Lin_[col]);
 
          GUM_ERROR(FatalError, "LRSWrapper< GUM_SCALAR >:: _initLrs_ : redundant columns !")
        }
      }
    }

References _dat_, _dic_, _fill_(), _getVolume_, _hull_, _input_, _Lin_, _lrsOutput_, _polytope_, _setUpStateNames_, _state_, GUM_ERROR, H2Vready, and V2Hready.

Referenced by computeVolume(), elimRedundVrep(), and H2V().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ computeVolume()

template<GUM_Numeric 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, therefore a pseudo-volume will be computed by projecting the polytope. The projection used is the lexicographically smallest coordinate subspace.

Definition at line 380 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_]);
 
      _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_();
    }

References _dat_, _dic_, _freeLrs_(), _getVolume_, _initLrs_(), _lrsOutput_, _setUpStateNames_, _state_, _volume_, BASE, GUM_ERROR, and V2Hready.

Here is the call graph for this function:

◆ elimRedundVrep()

template<GUM_Numeric 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 428 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_)]);
 
      _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_();
    }

References _dat_, _dic_, _freeLrs_(), _initLrs_(), _input_, _output_, _setUpStateNames_, _state_, _vertices_, GUM_ERROR, and V2Hready.

Here is the call graph for this function:

◆ fillH()

template<GUM_Numeric 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 205 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;
    }

References _card_, _input_, _insertedModals_, _setUpStateNames_, _state_, _vertex_, GUM_ERROR, H2Vready, and Hup.

Referenced by gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal().

Here is the caller graph for this function:

◆ fillMatrix()

template<GUM_Numeric 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 234 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;
    }

References _card_, _input_, _insertedModals_, _setUpStateNames_, _state_, GUM_ERROR, H2Vready, and Hup.

Referenced by gum::credal::lp::LpInterface< GUM_SCALAR >::solve().

Here is the caller graph for this function:

◆ fillV()

template<GUM_Numeric 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 258 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;
    }

References _card_, _input_, _insertedVertices_, _setUpStateNames_, _state_, _vertices_, GUM_ERROR, V2Hready, and Vup.

◆ getInput()

template<GUM_Numeric 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 77 of file LrsWrapper_tpl.h.

                                                                   {
      return _input_;
    }

References _input_.

◆ getOutput()

template<GUM_Numeric 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 82 of file LrsWrapper_tpl.h.

                                                                    {
      return _output_;
    }

References _output_.

Referenced by gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal(), and gum::credal::lp::LpInterface< GUM_SCALAR >::solve().

Here is the caller graph for this function:

◆ getVerticesNumber()

template<GUM_Numeric 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 87 of file LrsWrapper_tpl.h.

                                                                          {
      return _vertices_;
    }

References _vertices_.

◆ getVolume()

template<GUM_Numeric 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, therefore 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 92 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.");
    }

References _volume_, and GUM_ERROR.

◆ H2V()

template<GUM_Numeric 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 301 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 (gum::isCloseToOne(sum, GUM_SCALAR(1e-6))) {
        _output_ = std::vector< std::vector< GUM_SCALAR > >(1, _vertex_);
        return;
      }
 
      // not precise point probability, initialize lrs
 
      _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)) {
              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_();
    }

References _card_, _dat_, _dic_, _freeLrs_(), _getLRSWrapperOutput_(), _initLrs_(), _lrsOutput_, _output_, _setUpStateNames_, _state_, _vertex_, _vertices_, GUM_ERROR, H2Vready, and gum::isCloseToOne().

Referenced by gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal(), and gum::credal::lp::LpInterface< GUM_SCALAR >::solve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ nextHInput()

template<GUM_Numeric 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 therefore the input matrix _intput_ structure.

Definition at line 175 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();
      }
    }

References _card_, _getVolume_, _hull_, _input_, _insertedModals_, _insertedVertices_, _output_, _polytope_, _setUpStateNames_, _state_, _vertex_, _vertices_, _volume_, GUM_ERROR, H2Vready, Hup, none, V2Hready, and Vup.

Referenced by gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal().

Here is the caller graph for this function:

◆ setUpH()

template<GUM_Numeric 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 103 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;
    }

References _card_, _input_, _output_, _state_, _vertex_, GUM_ERROR, Hup, and tearDown().

Referenced by gum::credal::CredalNet< GUM_SCALAR >::intervalToCredal(), and gum::credal::lp::LpInterface< GUM_SCALAR >::solve().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setUpV()

template<GUM_Numeric 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 130 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;
    }

References _card_, _input_, _output_, _state_, _vertices_, GUM_ERROR, tearDown(), and Vup.

Here is the call graph for this function:

◆ tearDown()

template<GUM_Numeric 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 155 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;
    }

References _card_, _getVolume_, _hull_, _input_, _insertedModals_, _insertedVertices_, _output_, _polytope_, _state_, _vertex_, _vertices_, _volume_, and none.

Referenced by setUpH(), and setUpV().

Here is the caller graph for this function:

◆ V2H()

template<GUM_Numeric 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 370 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_]);
    }

References _setUpStateNames_, _state_, GUM_ERROR, and V2Hready.

Member Data Documentation

◆ _card_

template<GUM_Numeric GUM_SCALAR>

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

private

Cardinality of the variable.

Definition at line 134 of file LrsWrapper.h.

Referenced by LRSWrapper(), fillH(), fillMatrix(), fillV(), H2V(), nextHInput(), setUpH(), setUpV(), and tearDown().

◆ _dat_

template<GUM_Numeric GUM_SCALAR>

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

private

Structure for holding static problem data of lrs.

Definition at line 198 of file LrsWrapper.h.

Referenced by _fill_(), _freeLrs_(), _initLrs_(), computeVolume(), elimRedundVrep(), and H2V().

◆ _dic_

template<GUM_Numeric GUM_SCALAR>

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

private

Structure for holding current dictionary and indices of lrs.

Definition at line 195 of file LrsWrapper.h.

Referenced by _fill_(), _freeLrs_(), _initLrs_(), computeVolume(), elimRedundVrep(), and H2V().

◆ _getVolume_

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 213 of file LrsWrapper.h.

Referenced by LRSWrapper(), _initLrs_(), computeVolume(), nextHInput(), and tearDown().

◆ _hull_

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 215 of file LrsWrapper.h.

Referenced by LRSWrapper(), _initLrs_(), nextHInput(), and tearDown().

◆ _input_

template<GUM_Numeric GUM_SCALAR>

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

private

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

Definition at line 127 of file LrsWrapper.h.

Referenced by _fill_(), _initLrs_(), elimRedundVrep(), fillH(), fillMatrix(), fillV(), getInput(), nextHInput(), setUpH(), setUpV(), and tearDown().

◆ _insertedModals_

template<GUM_Numeric 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 138 of file LrsWrapper.h.

Referenced by fillH(), fillMatrix(), nextHInput(), and tearDown().

◆ _insertedVertices_

template<GUM_Numeric 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 146 of file LrsWrapper.h.

Referenced by fillV(), nextHInput(), and tearDown().

◆ _Lin_

template<GUM_Numeric GUM_SCALAR>

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

private

Holds lrs input linearities if any are found.

Definition at line 206 of file LrsWrapper.h.

Referenced by _freeLrs_(), and _initLrs_().

◆ _lrsOutput_

template<GUM_Numeric 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 203 of file LrsWrapper.h.

Referenced by _freeLrs_(), _initLrs_(), computeVolume(), and H2V().

◆ _oldCout_

template<GUM_Numeric 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 189 of file LrsWrapper.h.

◆ _output_

template<GUM_Numeric GUM_SCALAR>

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

private

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

Definition at line 131 of file LrsWrapper.h.

Referenced by elimRedundVrep(), getOutput(), H2V(), nextHInput(), setUpH(), setUpV(), and tearDown().

◆ _polytope_

template<GUM_Numeric GUM_SCALAR>

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

private

Definition at line 217 of file LrsWrapper.h.

Referenced by LRSWrapper(), _initLrs_(), nextHInput(), and tearDown().

◆ _setUpStateNames_

template<GUM_Numeric 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 173 of file LrsWrapper.h.

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

Referenced by _initLrs_(), computeVolume(), elimRedundVrep(), fillH(), fillMatrix(), fillV(), H2V(), nextHInput(), and V2H().

◆ _state_

template<GUM_Numeric GUM_SCALAR>

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

private

The current state of the LrsWrapper.

Definition at line 166 of file LrsWrapper.h.

Referenced by LRSWrapper(), _initLrs_(), computeVolume(), elimRedundVrep(), fillH(), fillMatrix(), fillV(), H2V(), nextHInput(), setUpH(), setUpV(), tearDown(), and V2H().

◆ _vertex_

template<GUM_Numeric 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 150 of file LrsWrapper.h.

Referenced by fillH(), H2V(), nextHInput(), setUpH(), and tearDown().

◆ _vertices_

template<GUM_Numeric GUM_SCALAR>

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

private

The number of vertices of the polytope.

Definition at line 141 of file LrsWrapper.h.

Referenced by LRSWrapper(), elimRedundVrep(), fillV(), getVerticesNumber(), H2V(), nextHInput(), setUpV(), and tearDown().

◆ _volume_

template<GUM_Numeric GUM_SCALAR>

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

private

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

Definition at line 169 of file LrsWrapper.h.

Referenced by LRSWrapper(), computeVolume(), getVolume(), nextHInput(), and tearDown().

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

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ matrix

Member Enumeration Documentation

◆ _states_

Constructor & Destructor Documentation

◆ LRSWrapper()

◆ ~LRSWrapper()

Member Function Documentation

◆ _fill_()

◆ _freeLrs_()

◆ _getLRSWrapperOutput_()

◆ _initLrs_()

◆ computeVolume()

◆ elimRedundVrep()

◆ fillH()

◆ fillMatrix()

◆ fillV()

◆ getInput()

◆ getOutput()

◆ getVerticesNumber()

◆ getVolume()

◆ H2V()

◆ nextHInput()

◆ setUpH()

◆ setUpV()

◆ tearDown()

◆ V2H()

Member Data Documentation

◆ _card_

◆ _dat_

◆ _dic_

◆ _getVolume_

◆ _hull_

◆ _input_

◆ _insertedModals_

◆ _insertedVertices_

◆ _Lin_

◆ _lrsOutput_

◆ _oldCout_

◆ _output_

◆ _polytope_

◆ _setUpStateNames_

◆ _state_

◆ _vertex_

◆ _vertices_

◆ _volume_