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 107 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 110 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 144 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 32 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 48 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 721 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 735 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 561 of file LrsWrapper_tpl.h.

References gum::Rational< GUM_SCALAR >::continuedFracFirst().

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

Here is the call graph for this function:

__freeLrs()

template<typename GUM_SCALAR >

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

private

Free lrs space.

Definition at line 692 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 502 of file LrsWrapper_tpl.h.

References BASE.

                                        {
      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 596 of file LrsWrapper_tpl.h.

References GUM_ERROR.

                                             {
      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 369 of file LrsWrapper_tpl.h.

References BASE, and GUM_ERROR.

                                                 {
      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 423 of file LrsWrapper_tpl.h.

References GUM_ERROR.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::_updateCredalSets().

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

Here is the caller graph for this function:

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 184 of file LrsWrapper_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

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 214 of file LrsWrapper_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

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 239 of file LrsWrapper_tpl.h.

References GUM_ERROR.

Referenced by gum::credal::InferenceEngine< GUM_SCALAR >::_updateCredalSets().

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

Here is the caller graph for this function:

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 53 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 58 of file LrsWrapper_tpl.h.

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

                                                                    {
      return __output;
    }

Here is the caller graph for this function:

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 63 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 68 of file LrsWrapper_tpl.h.

References GUM_ERROR.

                                                                {
      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 283 of file LrsWrapper_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

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 152 of file LrsWrapper_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

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 80 of file LrsWrapper_tpl.h.

References GUM_ERROR.

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

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

Here is the caller graph for this function:

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.

References GUM_ERROR.

Referenced by gum::credal::MultipleInferenceEngine< GUM_SCALAR, BNInferenceEngine >::__updateThreadCredalSets(), and gum::credal::InferenceEngine< GUM_SCALAR >::_updateCredalSets().

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

Here is the caller graph for this function:

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 132 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 359 of file LrsWrapper_tpl.h.

References GUM_ERROR.

                                       {
      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 121 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 114 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 125 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 133 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 118 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 137 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 128 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/LrsWrapper.h
• agrum/CN/LrsWrapper_tpl.h