gum::credal::lp::LpInterface< GUM_SCALAR > Class Template Reference

Class representing a linear program. More...

#include <agrum/CN/LpInterface.h>

Collaboration diagram for gum::credal::lp::LpInterface< GUM_SCALAR >:

Public Member Functions
LpCol	addCol ()
	Insert a new column, i.e. More...
std::vector< LpCol >	addCols (const unsigned int &cols)
	Insert new columns, i.e. More...
void	addRow (const LpExpr &expr)
	Add rows to the linear program according to a given expression ( which must be at least an inequality ). More...
void	addRow (LpExpr &&expr)
	Add rows to the linear program according to a given expression ( which must be at least an inequality ). More...
void	addPositivity ()
	Add positivity constraints for all variables. More...
void	addSumIsOne ()
	Add sum of variables is 1 constraints. More...
void	addProba ()
	Add positivity constraints and sum of variables is 1 ( probability constraints ) More...
std::vector< std::vector< GUM_SCALAR > >	solve ()
	Solve the linear program (H-representation of the polytope) by enumeration (of the polytope vertices) using lexicographic reverse search (lrs). More...
std::vector< LpCol >	getCols () const
	Get the variables of the LP. More...
std::string	toString () const
	Get the string representation of a calling linear program. More...
void	clear ()
	Reset the rows (inequalities) and columns (variables) of the LP as if it was created. More...
void	clearRows ()
	Reset the rows (inequalities) of the LP but not the columns (variables are kept). More...
Constructor / Destructor
	LpInterface ()
	Default constructor, empty problem. More...
	LpInterface (const LpInterface< GUM_SCALAR > &from)
	Copy constructor. More...
	LpInterface (LpInterface< GUM_SCALAR > &&from)
	Move copy constructor. More...
	~LpInterface ()
	Default destructor. More...
Compound assignment operator
LpInterface< GUM_SCALAR > &	operator= (const LpInterface< GUM_SCALAR > &from)
	Copy compound assignment. More...
LpInterface< GUM_SCALAR > &	operator= (LpInterface< GUM_SCALAR > &&from)
	Move coumpound assignment. More...

Friends
template<typename T >
std::ostream &	operator<< (std::ostream &out, const LpInterface< T > &lpi)
	Overload of << to use with output streams ( such as std::cout << ). More...

Detailed Description

template<typename GUM_SCALAR>
class gum::credal::lp::LpInterface< GUM_SCALAR >

Class representing a linear program.

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN()

Definition at line 48 of file LpInterface.h.

Constructor & Destructor Documentation

LpInterface() [1/3]

template<typename GUM_SCALAR >

gum::credal::lp::LpInterface< GUM_SCALAR >::LpInterface

(

)

Default constructor, empty problem.

class LpInterface

Definition at line 88 of file LpInterface_tpl.h.

                                             {
        positivity__ = false;
        sumIsOne__   = false;
        GUM_CONSTRUCTOR(LpInterface);
      }

LpInterface() [2/3]

template<typename GUM_SCALAR >

gum::credal::lp::LpInterface< GUM_SCALAR >::LpInterface

(

const LpInterface< GUM_SCALAR > &

from

)

Copy constructor.

Parameters

from	The LpInterface to be copied.

Definition at line 95 of file LpInterface_tpl.h.

                                                :
          cols__(from.cols__),
          positivity__(from.positivity__), sumIsOne__(from.sumIsOne__) {
        rows__.resize(from.rows__.size());

        for (unsigned int i = 0, end = from.rows__.size(); i < end; i++)
          rows__[i] = new LpRow(*from.rows__[i]);

        GUM_CONS_CPY(LpInterface);
      }

LpInterface() [3/3]

template<typename GUM_SCALAR >

gum::credal::lp::LpInterface< GUM_SCALAR >::LpInterface

(

LpInterface< GUM_SCALAR > &&

from

)

Move copy constructor.

Parameters

from	The temporary LpInterface to be moved.

Definition at line 108 of file LpInterface_tpl.h.

                                                                             :
          positivity__(from.positivity__), sumIsOne__(from.sumIsOne__) {
        rows__.swap(from.rows__);
        cols__.swap(from.cols__);
        GUM_CONS_CPY(LpInterface);
      }

~LpInterface()

template<typename GUM_SCALAR >

gum::credal::lp::LpInterface< GUM_SCALAR >::~LpInterface

(

)

Default destructor.

Definition at line 116 of file LpInterface_tpl.h.

                                              {
        for (const auto row: rows__)
          delete row;

        GUM_DESTRUCTOR(LpInterface);
      }

Member Function Documentation

addCol()

template<typename GUM_SCALAR >

LpCol gum::credal::lp::LpInterface< GUM_SCALAR >::addCol

(

)

Insert a new column, i.e.

a new variable.

Returns

A copy of the variable.

Definition at line 164 of file LpInterface_tpl.h.

                                              {
        LpCol col((unsigned int)cols__.size());

        cols__.push_back(col);

        return col;
      }

addCols()

template<typename GUM_SCALAR >

std::vector< LpCol > gum::credal::lp::LpInterface< GUM_SCALAR >::addCols

(

const unsigned int &

cols

)

Insert new columns, i.e.

new variables.

Parameters

cols	the constant reference to the number of variables we want.

Returns

The copy of the vector of all variables of the problem.

Definition at line 174 of file LpInterface_tpl.h.

                                                                    {
        if (cols < 1)
          GUM_ERROR(OperationNotAllowed,
                    "LpInterface::addCols ( cols ) : cols "
                    "needs must be equal or greater than 1 : "
                       << cols << " < 1");

        for (unsigned int i = 0; i < cols; i++) {
          cols__.push_back(LpCol((unsigned int)cols__.size()));
        }

        return cols__;
      }

addPositivity()

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::addPositivity

(

)

Add positivity constraints for all variables.

Definition at line 241 of file LpInterface_tpl.h.

                                                    {
        if (positivity__) return;

        for (const auto& col: cols__)
          addRow(0 <= col);

        positivity__ = true;
      }

addProba()

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::addProba

(

)

Add positivity constraints and sum of variables is 1 ( probability constraints )

Definition at line 265 of file LpInterface_tpl.h.

                                               {
        if (positivity__ && sumIsOne__) {
          return;
        } else if (positivity__ && !sumIsOne__) {
          addSumIsOne();
          return;
        } else if (!positivity__ && sumIsOne__) {
          addPositivity();
          return;
        }

        // we can do both with one loop, don't call the above functions.
        // addPositivity();
        // addSumIsOne();
        LpExpr expr;

        for (const auto& col: cols__) {
          addRow(0 <= col);
          expr += col;
        }

        addRow(1 <= std::move(expr) <= 1);

        sumIsOne__   = true;
        positivity__ = true;
      }

addRow() [1/2]

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::addRow

(

const LpExpr &

expr

)

Add rows to the linear program according to a given expression ( which must be at least an inequality ).

Parameters

expr	the constant reference to the expression to convert to rows.

Definition at line 189 of file LpInterface_tpl.h.

                                                               {
        if (!expr.ileft__ && !expr.iright__)
          GUM_ERROR(OperationNotAllowed,
                    "addRow ( const LpExpr & expr ) : expr : "
                       << expr.toString() << "is not an inequality.");

        if ((expr.ileft__ && !expr.iright__) || (!expr.ileft__ && expr.iright__)) {
          rows__.push_back(new LpRow(expr, cols__));
        } else {
          LpExpr lexpr(expr, true, true, false);
          LpExpr rexpr(expr, false, true, true);

          rows__.push_back(
             new LpRow(std::move(lexpr),
                       cols__));   
          rows__.push_back(
             new LpRow(std::move(rexpr),
                       cols__));   
        }
      }

addRow() [2/2]

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::addRow

(

LpExpr &&

expr

)

Add rows to the linear program according to a given expression ( which must be at least an inequality ).

Parameters

expr	the temporary expression to move to rows.

Definition at line 211 of file LpInterface_tpl.h.

                                                          {
        if (!expr.ileft__ && !expr.iright__)
          GUM_ERROR(OperationNotAllowed,
                    "addRow ( const LpExpr & expr ) : expr : "
                       << expr.toString() << "is not an inequality.");

        if ((expr.ileft__ && !expr.iright__) || (!expr.ileft__ && expr.iright__)) {
          rows__.push_back(new LpRow(std::move(expr), cols__));
        } else {
          LpExpr lexpr(std::move(expr), true, true, false);

          LpExpr rexpr(std::move(expr), false, false, true);


          *rexpr.mCoeffs__ = *lexpr.mCoeffs__;
          rexpr.mValue__   = lexpr.mValue__;
          rexpr.imiddle__  = true;

          rows__.push_back(
             new LpRow(std::move(lexpr),
                       cols__));   
          rows__.push_back(
             new LpRow(std::move(rexpr),
                       cols__));   
        }
      }

addSumIsOne()

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::addSumIsOne

(

)

Add sum of variables is 1 constraints.

Definition at line 251 of file LpInterface_tpl.h.

                                                  {
        if (sumIsOne__) return;

        LpExpr expr;

        for (const auto& col: cols__)
          expr += col;

        addRow(1 <= std::move(expr) <= 1);

        sumIsOne__ = true;
      }

clear()

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::clear

(

)

Reset the rows (inequalities) and columns (variables) of the LP as if it was created.

Definition at line 343 of file LpInterface_tpl.h.

                                            {
        for (const auto& row: rows__)
          delete row;

        rows__.clear();
        rows__.shrink_to_fit();   

        cols__.clear();
        cols__.shrink_to_fit();

        positivity__ = false;
        sumIsOne__   = false;
      }

clearRows()

template<typename GUM_SCALAR >

void gum::credal::lp::LpInterface< GUM_SCALAR >::clearRows

(

)

Reset the rows (inequalities) of the LP but not the columns (variables are kept).

Definition at line 361 of file LpInterface_tpl.h.

                                                {
        for (const auto& row: rows__)
          delete row;

        rows__.clear();
        rows__.shrink_to_fit();

        positivity__ = false;
        sumIsOne__   = false;
      }

getCols()

template<typename GUM_SCALAR >

std::vector< LpCol > gum::credal::lp::LpInterface< GUM_SCALAR >::getCols

(

)

const

Get the variables of the LP.

Returns

A copy of the variables as a vector of variables.

Definition at line 319 of file LpInterface_tpl.h.

                                                                  {
        return cols__;
      }

operator=() [1/2]

template<typename GUM_SCALAR >

LpInterface< GUM_SCALAR > & gum::credal::lp::LpInterface< GUM_SCALAR >::operator=

(

const LpInterface< GUM_SCALAR > &

from

)

Copy compound assignment.

Parameters

from	The LpInterface to be copied.

Definition at line 124 of file LpInterface_tpl.h.

                                                {
        for (const auto& row: rows__)
          delete row;

        rows__.clear();
        rows__.shrink_to_fit();

        rows__.resize(from.rows__.size());

        for (unsigned int i = 0, end = from.rows__.size(); i < end; i++)
          rows__[i] = new LpRow(*from.rows__[i]);

        cols__       = from.cols__;
        positivity__ = from.positivity__;
        sumIsOne__   = from.sumIsOne__;

        return *this;
      }

operator=() [2/2]

template<typename GUM_SCALAR >

LpInterface< GUM_SCALAR > & gum::credal::lp::LpInterface< GUM_SCALAR >::operator=

(

LpInterface< GUM_SCALAR > &&

from

)

Move coumpound assignment.

Parameters

from	The temporary LpInterface to be moved.

Definition at line 147 of file LpInterface_tpl.h.

                                                                              {
        rows__.swap(from.rows__);
        cols__.swap(from.cols__);

        positivity__ = from.positivity__;
        sumIsOne__   = from.sumIsOne__;

        return *this;
      }

solve()

template<typename GUM_SCALAR >

std::vector< std::vector< GUM_SCALAR > > gum::credal::lp::LpInterface< GUM_SCALAR >::solve

(

)

Solve the linear program (H-representation of the polytope) by enumeration (of the polytope vertices) using lexicographic reverse search (lrs).

Only works with bounded polyhedron (polytopes) and not unbounded ones (i.e. defined by vertices and rays).

Returns

The V-representation (vertices) of the polytope as a vector of vectors (vector of vertices).

Definition at line 293 of file LpInterface_tpl.h.

                                                                            {
        LRSWrapper< GUM_SCALAR > lrs;

        lrs.setUpH((unsigned int)cols__.size());

        std::vector< std::vector< GUM_SCALAR > > lrsMatrix;

        for (const auto& row: rows__) {
          std::vector< GUM_SCALAR > expandedRow(cols__.size() + 1, 0);

          expandedRow[0] = row->cste__;

          for (const auto& elt: *row->coeffs__)
            expandedRow[elt.first.id() + 1] = elt.second;

          lrsMatrix.push_back(expandedRow);
        }

        lrs.fillMatrix(lrsMatrix);

        lrs.H2V();

        return lrs.getOutput();
      }

toString()

template<typename GUM_SCALAR >

std::string gum::credal::lp::LpInterface< GUM_SCALAR >::toString

(

)

const

Get the string representation of a calling linear program.

Returns

The string representation of the calling linear program.

Definition at line 324 of file LpInterface_tpl.h.

                                                          {
        std::ostringstream s;

        s << std::endl << std::endl << "Variables : " << std::endl;

        for (const auto& col: cols__)
          s << " " << col.toString();

        s << std::endl;

        for (const auto& row: rows__)
          s << std::endl << row->toString();

        s << std::endl << std::endl;

        return s.str();
      }

Friends And Related Function Documentation

operator<<

template<typename GUM_SCALAR >

template<typename T >

std::ostream& operator<< ( std::ostream &  out, const LpInterface< T > &  lpi  )

friend

Overload of << to use with output streams ( such as std::cout << ).

Parameters

out	the reference to the caller, i.e. left side of <<.
lpi	the constant reference to the linear program whose representation we want.

Returns

The address of the caller.

Definition at line 158 of file LpInterface_tpl.h.

                                                                           {
        out << lpi.toString();
        return out;
      }

Member Data Documentation

cols__

template<typename GUM_SCALAR >

std::vector< LpCol > gum::credal::lp::LpInterface< GUM_SCALAR >::cols__

private

Variables of the problem.

Definition at line 753 of file LpInterface.h.

positivity__

template<typename GUM_SCALAR >

bool gum::credal::lp::LpInterface< GUM_SCALAR >::positivity__

private

true if addPositivity() has been called, false otherwise.

Definition at line 757 of file LpInterface.h.

rows__

template<typename GUM_SCALAR >

std::vector< LpRow* > gum::credal::lp::LpInterface< GUM_SCALAR >::rows__

private

Rows of the problem.

Definition at line 751 of file LpInterface.h.

sumIsOne__

template<typename GUM_SCALAR >

bool gum::credal::lp::LpInterface< GUM_SCALAR >::sumIsOne__

private

true if addSumIsOne() has been called, false otherwise.

Definition at line 760 of file LpInterface.h.

---

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

• agrum/CN/polytope/LpInterface.h
• agrum/CN/polytope/LpInterface_tpl.h