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 501 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 593 of file LpInterface_tpl.h.

References __coeffs, __cste, gum::credal::lp::LpExpr::__ileft, gum::credal::lp::LpExpr::__iright, gum::credal::lp::LpExpr::__lCoeffs, gum::credal::lp::LpExpr::__lValue, gum::credal::lp::LpExpr::__mCoeffs, gum::credal::lp::LpExpr::__mValue, gum::credal::lp::LpExpr::__rCoeffs, gum::credal::lp::LpExpr::__rValue, GUM_ERROR, and gum::credal::lp::LpExpr::toString().

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

Here is the call 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 639 of file LpInterface_tpl.h.

References __coeffs, __cste, GUM_ERROR, and gum::credal::lp::swap().

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

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 683 of file LpInterface_tpl.h.

                                   :
          __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 689 of file LpInterface_tpl.h.

                              : __cste(row.__cste), __coeffs(row.__coeffs) {
        row.__coeffs = nullptr;

        GUM_CONS_CPY(LpRow);
      }

~LpRow()

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

(

)

Default destructor.

Definition at line 695 of file LpInterface_tpl.h.

References __coeffs.

                    {
        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 701 of file LpInterface_tpl.h.

References __coeffs, and __cste.

                                              {
        __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 707 of file LpInterface_tpl.h.

References __coeffs, __cste, and gum::credal::lp::swap().

                                         {
        __cste = row.__cste;
        swap(__coeffs, row.__coeffs);
        return *this;
      }

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 718 of file LpInterface_tpl.h.

References __coeffs, and __cste.

Referenced by gum::credal::lp::operator<<().

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

Here is the caller graph for this function:

Friends And Related Function Documentation

LpInterface

template<typename GUM_SCALAR >

friend class LpInterface

friend

Definition at line 503 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 713 of file LpInterface_tpl.h.

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

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

__cste

double gum::credal::lp::LpRow::__cste

private

The constant of the linear inequality.

Definition at line 589 of file LpInterface.h.

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

---

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

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