gum::credal::lp::LpRow Class Reference

Class representing a row of the linear program, i.e. More...

#include <agrum/CN/LpInterface.h>

Collaboration diagram for gum::credal::lp::LpRow:

Public Member Functions
std::string	toString () const
	Get the string representation of a calling row.
Constructors / Destructors
	LpRow (const LpExpr &expr, const std::vector< LpCol > &cols)
	Constructor from an expression and the address of the vector of variables of the problem.
	LpRow (LpExpr &&expr, const std::vector< LpCol > &cols)
	Move constructor from a temporary expression and the address of the vector of variables of the problem.
	LpRow (const LpRow &row)
	Copy constructor.
	LpRow (LpRow &&row)
	Move copy constructor from temporary.
	~LpRow ()
	Default destructor.
Assignment operators
LpRow &	operator= (const LpRow &row)
LpRow &	operator= (LpRow &&row)

Private Attributes
double	_cste_
	The constant of the linear inequality.
HashTable< LpCol, double > *	_coeffs_
	The coefficients of the variables of the linear inequality.

Friends
template<GUM_Numeric GUM_SCALAR>
class	LpInterface
std::ostream &	operator<< (std::ostream &out, const LpRow &row)
	Overload of << to use with output streams ( such as std::cout << ).

Detailed Description

Class representing a row of the linear program, i.e.

an inequality.

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN(_at_LIP6)

Definition at line 521 of file LpInterface.h.

Constructor & Destructor Documentation

LpRow() [1/4]

gum::credal::lp::LpRow::LpRow	(	const LpExpr &	expr,
		const std::vector< LpCol > &	cols )

Constructor from an expression and the address of the vector of variables of the problem.

class LpRow

Parameters

expr	the constant reference to the expression to convert into rows ( inequalities ).
cols	the constant reference to the vector of variables of the problem.

Definition at line 519 of file LpInterface.cpp.

                                                                     : _coeffs_(nullptr) {
        // we write 0 <= Ax + b from Ex + f <= Cx + d
        if (expr._ileft_ && !expr._iright_) {
          _coeffs_ = new HashTable< LpCol, double >(*expr._mCoeffs_);
 
          for (const auto& col: cols) {
            double col_coeff = 0.;
 
            // from left side to middle side : 0 <= middle - left
            if (expr._lCoeffs_->exists(col)) col_coeff = expr._lCoeffs_->operator[](col);
 
            _coeffs_->getWithDefault(col, 0.) -= col_coeff;
          }
 
          _cste_ = expr._mValue_ - expr._lValue_;
        } else if (expr._iright_ && !expr._ileft_) {
          _coeffs_ = new HashTable< LpCol, double >(*expr._rCoeffs_);
 
          for (const auto& col: cols) {
            double col_coeff = 0;
 
            // from middle side to right side : 0 <= right - middle
            if (expr._mCoeffs_->exists(col)) col_coeff = expr._mCoeffs_->operator[](col);
 
            _coeffs_->getWithDefault(col, 0.) -= col_coeff;
          }
 
          _cste_ = expr._rValue_ - expr._mValue_;
        } else
          GUM_ERROR(OperationNotAllowed,
                    "expr : " << expr.toString() << "is not a valid inequality; no <= detected");
 
        if (_coeffs_->size() == 0)
          GUM_ERROR(OperationNotAllowed,
                    "expr : " << expr.toString()
                              << "is not a valid inequality; "
                                 "no variable in inequality, "
                                 "only constants");
 
        GUM_CONSTRUCTOR(LpRow);
      }

References _coeffs_, _cste_, gum::credal::lp::LpExpr::_ileft_, gum::credal::lp::LpExpr::_iright_, gum::credal::lp::LpExpr::_lValue_, and gum::credal::lp::LpExpr::_mValue_.

Referenced by LpRow(), LpRow(), LpRow(), ~LpRow(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), LpInterface, operator<<, gum::credal::lp::LpInterface< GUM_SCALAR >::operator=(), operator=(), and operator=().

Here is the caller graph for this function:

LpRow() [2/4]

gum::credal::lp::LpRow::LpRow	(	LpExpr &&	expr,
		const std::vector< LpCol > &	cols )

Move constructor from a temporary expression and the address of the vector of variables of the problem.

Parameters

expr	the temporary expression to move into rows ( inequalities ).
cols	the constant reference to the vector of variables of the problem.

Definition at line 561 of file LpInterface.cpp.

                                                                : _coeffs_(nullptr) {
        if (expr._ileft_ && !expr._iright_) {
          swap(_coeffs_, expr._mCoeffs_);
 
          for (const auto& col: cols) {
            double col_coeff = 0;
 
            if (expr._lCoeffs_->exists(col)) col_coeff = expr._lCoeffs_->operator[](col);
 
            _coeffs_->getWithDefault(col, 0.) -= col_coeff;
          }
 
          _cste_ = expr._mValue_ - expr._lValue_;
        } else if (expr._iright_ && !expr._ileft_) {
          swap(_coeffs_, expr._rCoeffs_);
 
          for (const auto& col: cols) {
            double col_coeff = 0;
 
            if (expr._mCoeffs_->exists(col)) col_coeff = expr._mCoeffs_->operator[](col);
 
            _coeffs_->getWithDefault(col, 0.) -= col_coeff;
          }
 
          _cste_ = expr._rValue_ - expr._mValue_;
        } else
          GUM_ERROR(OperationNotAllowed,
                    "expr : " << expr.toString() << "is not a valid inequality; no <= detected");
 
        if (_coeffs_->size() == 0)
          GUM_ERROR(OperationNotAllowed,
                    "expr : " << expr.toString()
                              << "is not a valid inequality; "
                                 "no variable in inequality, "
                                 "only constants");
 
        GUM_CONSTRUCTOR(LpRow);
      }

References LpRow(), _coeffs_, and _cste_.

Here is the call graph for this function:

LpRow() [3/4]

gum::credal::lp::LpRow::LpRow

(

const LpRow &

row

)

Copy constructor.

Parameters

row	The constant reference to the row to be copied.

Definition at line 601 of file LpInterface.cpp.

                                   :
          _cste_(row._cste_), _coeffs_(new HashTable< LpCol, double >(*row._coeffs_)) {
        GUM_CONS_CPY(LpRow);
      }

References LpRow(), _coeffs_, and _cste_.

Here is the call graph for this function:

LpRow() [4/4]

gum::credal::lp::LpRow::LpRow

(

LpRow &&

row

)

Move copy constructor from temporary.

Parameters

row	The temporary row to be copied.

Definition at line 606 of file LpInterface.cpp.

                              : _cste_(row._cste_), _coeffs_(row._coeffs_) {
        row._coeffs_ = nullptr;
 
        GUM_CONS_CPY(LpRow);
      }

References LpRow(), _coeffs_, and _cste_.

Here is the call graph for this function:

~LpRow()

gum::credal::lp::LpRow::~LpRow

(

)

Default destructor.

Definition at line 612 of file LpInterface.cpp.

                    {
        delete _coeffs_;
 
        GUM_DESTRUCTOR(LpRow);
      }

References LpRow(), and _coeffs_.

Here is the call graph for this function:

Member Function Documentation

operator=() [1/2]

LpRow & gum::credal::lp::LpRow::operator=

(

const LpRow &

row

)

Parameters

row	The constant reference to the row to be copied.

Definition at line 618 of file LpInterface.cpp.

                                            {
        _cste_    = row._cste_;
        *_coeffs_ = *row._coeffs_;
        return *this;
      }

References LpRow(), _coeffs_, and _cste_.

Referenced by LpInterface.

Here is the call graph for this function:

Here is the caller graph for this function:

operator=() [2/2]

LpRow & gum::credal::lp::LpRow::operator=

(

LpRow &&

row

)

Parameters

row	The temporary row to be moved to this.

Definition at line 624 of file LpInterface.cpp.

                                       {
        _cste_ = row._cste_;
        swap(_coeffs_, row._coeffs_);
        return *this;
      }

References LpRow(), _coeffs_, _cste_, and gum::credal::lp::swap().

Here is the call graph for this function:

toString()

std::string gum::credal::lp::LpRow::toString

(

)

const

Get the string representation of a calling row.

Returns

The string representation of the calling row.

Definition at line 635 of file LpInterface.cpp.

                                      {
        std::string s = std::format("0 <= {}", _cste_);
 
        if (_coeffs_ != nullptr) {
          for (const auto& elt: *_coeffs_) {
            if (elt.second > 0) {
              if (elt.second != 1) {
                s += std::format(" +{}*{}", elt.second, elt.first.toString());
              } else {
                s += std::format(" +{}", elt.first.toString());
              }
            } else {
              if (elt.second < 0) {
                if (elt.second != -1) {
                  s += std::format(" {}*{}", elt.second, elt.first.toString());
                } else {
                  s += std::format(" -{}", elt.first.toString());
                }
              }
            }
          }
        }
 
        return s;
      }

References _coeffs_, and _cste_.

Referenced by LpInterface, and operator<<.

Here is the caller graph for this function:

Friends And Related Symbol Documentation

LpInterface

template<GUM_Numeric GUM_SCALAR>

friend class LpInterface

friend

Definition at line 523 of file LpInterface.h.

References LpRow(), LpInterface, operator<<, operator=(), and toString().

Referenced by LpInterface.

operator<<

std::ostream & operator<< ( std::ostream & out, const LpRow & row )

friend

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

Parameters

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

Returns

The address of the caller.

Definition at line 630 of file LpInterface.cpp.

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

References LpRow(), operator<<, and toString().

Referenced by LpInterface, and operator<<.

Member Data Documentation

_coeffs_

HashTable< LpCol, double >* gum::credal::lp::LpRow::_coeffs_

private

The coefficients of the variables of the linear inequality.

Definition at line 613 of file LpInterface.h.

Referenced by LpRow(), LpRow(), LpRow(), LpRow(), ~LpRow(), operator=(), operator=(), and toString().

_cste_

double gum::credal::lp::LpRow::_cste_

private

The constant of the linear inequality.

Definition at line 609 of file LpInterface.h.

Referenced by LpRow(), LpRow(), LpRow(), LpRow(), operator=(), operator=(), and toString().

---

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

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