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

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 370 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__();
    }

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 724 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 738 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
    }

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 424 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__();
    }

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 562 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;
    }

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 185 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 215 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 240 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;
    }

freeLrs__()

template<typename GUM_SCALAR >

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

private

Free lrs space.

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

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__;
    }

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 503 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);
    }

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 284 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__();
    }

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 599 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 !" );
  }
  */
    }

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 153 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 107 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 133 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 360 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