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. More...
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. More...
	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. More...
	LpRow (const LpRow &row)
	Copy constructor. More...
	LpRow (LpRow &&row)
	Move copy constructor from temporary. More...
	~LpRow ()
	Default destructor. More...
Assignment operators
LpRow &	operator= (const LpRow &row)
LpRow &	operator= (LpRow &&row)

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

Detailed Description

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

an inequality.

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN()

Definition at line 499 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 513 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);
      }

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

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 595 of file LpInterface.cpp.

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

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 600 of file LpInterface.cpp.

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

        GUM_CONS_CPY(LpRow);
      }

~LpRow()

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

(

)

Default destructor.

Definition at line 606 of file LpInterface.cpp.

                    {
        delete _coeffs_;

        GUM_DESTRUCTOR(LpRow);
      }

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 612 of file LpInterface.cpp.

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

operator=() [2/2]

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

(

LpRow &&

row

)

Parameters

row	The temporary row to be moved to this.

Definition at line 618 of file LpInterface.cpp.

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

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 629 of file LpInterface.cpp.

                                      {
        std::ostringstream s;

        s << "0 <= " << _cste_;

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

        return s.str();
      }

Friends And Related Function Documentation

LpInterface

template<typename GUM_SCALAR >

friend class LpInterface

friend

Definition at line 501 of file LpInterface.h.

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 624 of file LpInterface.cpp.

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

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 590 of file LpInterface.h.

_cste_

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

private

The constant of the linear inequality.

Definition at line 586 of file LpInterface.h.

---

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

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