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 500 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 521 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 567 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 611 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 617 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 623 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 629 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 635 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 646 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 502 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 641 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 592 of file LpInterface.h.

cste__

double gum::credal::lp::LpRow::cste__

private

The constant of the linear inequality.

Definition at line 588 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