gum::credal::lp::LpExpr Class Reference

Class representing a linear expression. More...

#include <agrum/CN/LpInterface.h>

Collaboration diagram for gum::credal::lp::LpExpr:

Public Member Functions
void	clear ()
	Clear all data of the calling expression as if it was constructed. More...
std::string	toString () const
	Get the string representation of a calling expression. More...
template<typename SCALAR >
INLINE LpExpr	multiply (const SCALAR &lhs, const LpCol &rhs)
template<typename T1 , typename T2 >
INLINE LpExpr	lessThan (T1 &&lhs, T2 &&rhs)
Constructors / Destructors
	LpExpr ()
	Default constructor. More...
	LpExpr (const LpExpr &expr)
	Copy constructor. More...
	LpExpr (const LpExpr &expr, bool copyLeft, bool copyMiddle, bool copyRight)
	Copy constructor. More...
	LpExpr (LpExpr &&expr)
	Move copy constructor from temporary. More...
	LpExpr (LpExpr &&expr, bool copyLeft, bool copyMiddle, bool copyRight)
	Move copy constructor from temporary. More...
	~LpExpr ()
	Default destructor. More...
Assignment operators =
LpExpr &	operator= (const LpCol &rhs)
	Assignment operator = with a variable. More...
LpExpr &	operator= (const LpExpr &rhs)
	Assignment operator = with another expression, by copy. More...
LpExpr &	operator= (LpExpr &&rhs)
	Assignment operator = with another expression, by move. More...
template<typename SCALAR >
LpExpr &	operator= (const SCALAR &rhs)
	Assignment operator = with a scalar. More...
Compound assignment operators +=
LpExpr &	operator+= (const LpCol &rhs)
	Compound assignment operator += with a variable. More...
LpExpr &	operator+= (const LpExpr &rhs)
	Compound assignment operator += with another expression. More...
LpExpr &	operator+= (LpExpr &&rhs)
	Compound assignment operator += with another temporary expression. More...
template<typename T >
LpExpr &	operator+= (const T &rhs)
	Compound assignment operator += with a scalar. More...
Compound assignment operators -=
LpExpr &	operator-= (const LpCol &rhs)
	Compound assignment operator -= with a variable. More...
LpExpr &	operator-= (const LpExpr &rhs)
	Compound assignment operator -= with another expression. More...
template<typename T >
LpExpr &	operator-= (const T &rhs)
	Compound assignment operator -= with a salar. More...

Static Public Member Functions
Helper static methods for operations
template<typename T1 , typename T2 >
static LpExpr	lessThan (T1 &&lhs, T2 &&rhs)
template<typename SCALAR >
static LpExpr	multiply (const SCALAR &lhs, const LpCol &rhs)

Friends
class	LpRow
template<typename GUM_SCALAR >
class	LpInterface

Detailed Description

Class representing a linear expression.

Author

Matthieu HOURBRACQ and Pierre-Henri WUILLEMIN()

Definition at line 208 of file LpInterface.h.

Constructor & Destructor Documentation

LpExpr() [1/5]

gum::credal::lp::LpExpr::LpExpr

(

)

Default constructor.

class LpExpr

Definition at line 63 of file LpInterface.cpp.

                     :
          _ileft_(false), _imiddle_(false), _iright_(false), _lValue_(0.), _mValue_(0.),
          _rValue_(0.), _lCoeffs_(new HashTable< LpCol, double >()),
          _mCoeffs_(new HashTable< LpCol, double >()), _rCoeffs_(new HashTable< LpCol, double >()) {
        GUM_CONSTRUCTOR(LpExpr);
      }

LpExpr() [2/5]

gum::credal::lp::LpExpr::LpExpr

(

const LpExpr &

expr

)

Copy constructor.

Parameters

expr	The constant reference to the expression to copy.

Definition at line 70 of file LpInterface.cpp.

                                       :
          _ileft_(expr._ileft_), _imiddle_(expr._imiddle_), _iright_(expr._iright_),
          _lValue_(expr._lValue_), _mValue_(expr._mValue_), _rValue_(expr._rValue_),
          _lCoeffs_(new HashTable< LpCol, double >(*expr._lCoeffs_)),
          _mCoeffs_(new HashTable< LpCol, double >(*expr._mCoeffs_)),
          _rCoeffs_(new HashTable< LpCol, double >(*expr._rCoeffs_)) {
        GUM_CONS_CPY(LpExpr);
      }

LpExpr() [3/5]

gum::credal::lp::LpExpr::LpExpr	(	const LpExpr &	expr,
		bool	copyLeft,
		bool	copyMiddle,
		bool	copyRight
	)

Copy constructor.

Makes a ( partial ) copy.

Parameters

expr	The constant reference to the expression to copy.
copyLeft	True if we want to copy left side of expr, False otherwise.
copyMiddle	True if we want to copy middle side of expr, False otherwise.
copyRight	True if we want to copy right side of expr, False otherwise.

Definition at line 79 of file LpInterface.cpp.

                                                                                       :
          _ileft_(false), _imiddle_(false), _iright_(false), _lValue_(0.), _mValue_(0.),
          _rValue_(0.), _lCoeffs_(nullptr), _mCoeffs_(nullptr), _rCoeffs_(nullptr) {
        if (copyLeft) {
          _lCoeffs_ = new HashTable< LpCol, double >(*expr._lCoeffs_);
          _lValue_  = expr._lValue_;
          _ileft_   = true;
        } else
          _lCoeffs_ = new HashTable< LpCol, double >();

        if (copyMiddle) {
          _mCoeffs_ = new HashTable< LpCol, double >(*expr._mCoeffs_);
          _mValue_  = expr._mValue_;
          _imiddle_ = true;
        } else
          _mCoeffs_ = new HashTable< LpCol, double >();

        if (copyRight) {
          _rCoeffs_ = new HashTable< LpCol, double >(*expr._rCoeffs_);
          _rValue_  = expr._rValue_;
          _iright_  = true;
        } else
          _rCoeffs_ = new HashTable< LpCol, double >();

        GUM_CONS_CPY(LpExpr);
      }

LpExpr() [4/5]

gum::credal::lp::LpExpr::LpExpr

(

LpExpr &&

expr

)

Move copy constructor from temporary.

Swap ressources between the temporary expr and the caller instead of copying the temporary.

Parameters

expr	The temporary expression to move to this.

Definition at line 106 of file LpInterface.cpp.

                                  :
          _ileft_(expr._ileft_), _imiddle_(expr._imiddle_), _iright_(expr._iright_),
          _lValue_(expr._lValue_), _mValue_(expr._mValue_), _rValue_(expr._rValue_),
          _lCoeffs_(expr._lCoeffs_), _mCoeffs_(expr._mCoeffs_), _rCoeffs_(expr._rCoeffs_) {
        expr._lCoeffs_ = nullptr;
        expr._mCoeffs_ = nullptr;
        expr._rCoeffs_ = nullptr;

        GUM_CONS_CPY(LpExpr);
      }

LpExpr() [5/5]

gum::credal::lp::LpExpr::LpExpr	(	LpExpr &&	expr,
		bool	copyLeft,
		bool	copyMiddle,
		bool	copyRight
	)

Move copy constructor from temporary.

Makes ( partial ) moves.

Warning

Proceed with care; partial moves are dangerous because the object being moved may still briefly exist after being moved and could be used afterward.

Parameters

expr	The temporary expression to ( partially ) move to this.
copyLeft	True if we want to copy left side of expr, False otherwise.
copyMiddle	True if we want to copy middle side of expr, False otherwise.
copyRight	True if we want to copy right side of expr, False otherwise.

Definition at line 117 of file LpInterface.cpp.

                                                                                  :
          _ileft_(false), _imiddle_(false), _iright_(false), _lValue_(0.), _mValue_(0.),
          _rValue_(0.), _lCoeffs_(nullptr), _mCoeffs_(nullptr), _rCoeffs_(nullptr) {
        if (copyLeft) {
          swap(_lCoeffs_, expr._lCoeffs_);
          _lValue_ = expr._lValue_;
          _ileft_  = true;
        } else
          _lCoeffs_ = new HashTable< LpCol, double >();

        if (copyMiddle) {
          swap(_mCoeffs_, expr._mCoeffs_);
          _mValue_  = expr._mValue_;
          _imiddle_ = true;
        } else
          _mCoeffs_ = new HashTable< LpCol, double >();

        if (copyRight) {
          swap(_rCoeffs_, expr._rCoeffs_);
          _rValue_ = expr._rValue_;
          _iright_ = true;
        } else
          _rCoeffs_ = new HashTable< LpCol, double >();

        GUM_CONS_CPY(LpExpr);
      }

~LpExpr()

gum::credal::lp::LpExpr::~LpExpr

(

)

Default destructor.

Definition at line 144 of file LpInterface.cpp.

                      {
        delete _lCoeffs_;
        delete _mCoeffs_;
        delete _rCoeffs_;

        GUM_DESTRUCTOR(LpExpr);
      }

Member Function Documentation

_addSide_() [1/4]

void gum::credal::lp::LpExpr::_addSide_ ( const LpCol &  from )

private

Set the side of the calling expression, from LEFT TO RIGHT : L <= M <= R.

Parameters

from	the constant reference to the variable ( the side ) to put on the first empty side met, starting at left.

Definition at line 275 of file LpInterface.cpp.

                                              {
        if (!_ileft_) {
          _lCoeffs_->insert(from, 1.);
          _ileft_ = true;
        } else if (!_imiddle_) {
          _mCoeffs_->insert(from, 1.);
          _imiddle_ = true;
        } else if (!_iright_) {
          _rCoeffs_->insert(from, 1.);
          _iright_ = true;
        } else
          GUM_ERROR(OperationNotAllowed,
                    "LpExpr::setSide ( const LpCol & from "
                    ") : too many <= ; no free side");
      }

_addSide_() [2/4]

void gum::credal::lp::LpExpr::_addSide_ ( const LpExpr &  from )

private

Copy an expression to a side of the calling expression, from LEFT TO RIGHT : L <= M <= R.

Parameters

from	the constant reference to the expression ( the side ) to copy on the first empty side met, starting at left.

Definition at line 291 of file LpInterface.cpp.

                                               {
        if (_ileft_ && _iright_ && from._imiddle_)
          GUM_ERROR(OperationNotAllowed,
                    "LpExpr::setSide ( const LpCol & from "
                    ") : too many <= ; no free side");

        if (!from._imiddle_) return;

        if (!from._ileft_ && !from._iright_) {
          if (!_ileft_) {
            *_lCoeffs_ = *from._mCoeffs_;
            _lValue_   = from._mValue_;
            _ileft_    = true;

            return;
          } else if (!_imiddle_) {
            *_mCoeffs_ = *from._mCoeffs_;
            _mValue_   = from._mValue_;
            _imiddle_  = true;

            return;
          } else if (!_iright_) {
            *_rCoeffs_ = *from._mCoeffs_;
            _rValue_   = from._mValue_;
            _iright_   = true;

            return;
          } else
            GUM_ERROR(OperationNotAllowed,
                      "LpExpr::setSide ( const LpCol & from ) "
                      ": too many <= ; no free side");
        }
        else if (from._ileft_ && !from._iright_) {
          if (!_ileft_) {
            *_lCoeffs_ = *from._lCoeffs_;
            _lValue_   = from._lValue_;
            _ileft_    = true;

            *_mCoeffs_ = *from._mCoeffs_;
            _mValue_   = from._mValue_;
            _imiddle_  = true;

            return;
          } else if (!_imiddle_ && !_iright_) {
            *_mCoeffs_ = *from._lCoeffs_;
            _mValue_   = from._lValue_;
            _imiddle_  = true;

            *_rCoeffs_ = *from._mCoeffs_;
            _rValue_   = from._mValue_;
            _iright_   = true;

            return;
          } else
            GUM_ERROR(OperationNotAllowed,
                      "LpExpr::setSide ( const LpCol & from ) "
                      ": too many <= ; no free side");
        }
        else if (from._ileft_ && from._iright_) {
          if (_ileft_ || _imiddle_ || _iright_)
            GUM_ERROR(OperationNotAllowed,
                      "LpExpr::setSide ( const LpCol & from ) "
                      ": too many <= ; no free side");

          *this = from;

          return;
        } else
          GUM_ERROR(OperationNotAllowed,
                    "LpExpr::setSide ( const LpCol & from "
                    ") : too many <= ; no free side");
      }

_addSide_() [3/4]

void gum::credal::lp::LpExpr::_addSide_ ( LpExpr &&  from )

private

Move an expression to a side of the calling expression, from LEFT TO RIGHT : L <= M <= R.

Parameters

from	the expression ( the side ) to move on the first empty side met, starting at left.

Definition at line 372 of file LpInterface.cpp.

                                          {
        if (_ileft_ && _iright_ && from._imiddle_)
          GUM_ERROR(OperationNotAllowed,
                    "LpExpr::setSide ( const LpCol & from "
                    ") : too many <= ; no free side");

        if (!from._imiddle_) return;

        if (!from._ileft_ && !from._iright_) {
          if (!_ileft_) {
            swap(_lCoeffs_, from._mCoeffs_);
            _lValue_ = from._mValue_;
            _ileft_  = true;

            return;
          } else if (!_imiddle_) {
            swap(_mCoeffs_, from._mCoeffs_);
            _mValue_  = from._mValue_;
            _imiddle_ = true;

            return;
          } else if (!_iright_) {
            swap(_rCoeffs_, from._mCoeffs_);
            _rValue_ = from._mValue_;
            _iright_ = true;

            return;
          } else
            GUM_ERROR(OperationNotAllowed,
                      "LpExpr::setSide ( const LpCol & from ) "
                      ": too many <= ; no free side");
        }
        else if (from._ileft_ && !from._iright_) {
          if (!_ileft_) {
            swap(_lCoeffs_, from._lCoeffs_);
            _lValue_ = from._lValue_;
            _ileft_  = true;

            swap(_mCoeffs_, from._mCoeffs_);
            _mValue_  = from._mValue_;
            _imiddle_ = true;

            return;
          } else if (!_imiddle_ && !_iright_) {
            swap(_mCoeffs_, from._lCoeffs_);
            _mValue_  = from._lValue_;
            _imiddle_ = true;

            swap(_rCoeffs_, from._mCoeffs_);
            _rValue_ = from._mValue_;
            _iright_ = true;

            return;
          } else
            GUM_ERROR(OperationNotAllowed,
                      "LpExpr::setSide ( const LpCol & from ) "
                      ": too many <= ; no free side");
        }
        else if (from._ileft_ && from._iright_) {
          if (_ileft_ || _imiddle_ || _iright_)
            GUM_ERROR(OperationNotAllowed,
                      "LpExpr::setSide ( const LpCol & from ) "
                      ": too many <= ; no free side");

          *this = std::move(from);

          return;
        } else
          GUM_ERROR(OperationNotAllowed,
                    "LpExpr::setSide ( const LpCol & from "
                    ") : too many <= ; no free side");
      }

_addSide_() [4/4]

template<typename SCALAR >

void gum::credal::lp::LpExpr::_addSide_ ( const SCALAR &  from )

private

Set the side of the calling expression, from LEFT TO RIGHT : L <= M <= R.

Template Parameters

SCALAR

A scalar type ( integer or float ( any precision ) ).

Parameters

from	the constant reference to the scalar ( the side ) to put on the first empty side met, starting at left.

Definition at line 66 of file LpInterface_tpl.h.

                                               {
        if (!_ileft_) {
          _lValue_ = from;
          _ileft_  = true;
        } else if (!_imiddle_) {
          _mValue_  = from;
          _imiddle_ = true;
        } else if (!_iright_) {
          _rValue_ = from;
          _iright_ = true;
        } else
          GUM_ERROR(OperationNotAllowed,
                    "LpExpr::setSide ( const LpCol & from "
                    ") : too many <= ; no free side");
      }

clear()

void gum::credal::lp::LpExpr::clear

(

)

Clear all data of the calling expression as if it was constructed.

Definition at line 462 of file LpInterface.cpp.

                         {
        _lCoeffs_->clear();
        _mCoeffs_->clear();
        _rCoeffs_->clear();

        _lValue_ = 0.;
        _mValue_ = 0.;
        _rValue_ = 0.;

        _ileft_   = false;
        _imiddle_ = false;
        _iright_  = false;
      }

lessThan() [1/2]

template<typename T1 , typename T2 >

static LpExpr gum::credal::lp::LpExpr::lessThan ( T1 &&  lhs, T2 &&  rhs  )

static

lessThan() [2/2]

template<typename T1 , typename T2 >

INLINE LpExpr gum::credal::lp::LpExpr::lessThan	(	T1 &&	lhs,
		T2 &&	rhs
	)

Definition at line 490 of file LpInterface_tpl.h.

                                                       {
        LpExpr expr;
        expr._addSide_(std::forward< T1 >(lhs));
        expr._addSide_(std::forward< T2 >(rhs));
        return expr;
      }

multiply() [1/2]

template<typename SCALAR >

static LpExpr gum::credal::lp::LpExpr::multiply ( const SCALAR &  lhs, const LpCol &  rhs  )

static

multiply() [2/2]

template<typename SCALAR >

INLINE LpExpr gum::credal::lp::LpExpr::multiply	(	const SCALAR &	lhs,
		const LpCol &	rhs
	)

Definition at line 471 of file LpInterface_tpl.h.

                                                                        {
        LpExpr expr;
        expr._mCoeffs_->insert(rhs, lhs);
        expr._imiddle_ = true;
        return expr;
      }

operator+=() [1/4]

LpExpr & gum::credal::lp::LpExpr::operator+=

(

const LpCol &

rhs

)

Compound assignment operator += with a variable.

Parameters

rhs	the constant reference to the variable to add to the calling expression.

Returns

The reference of the calling expression.

Definition at line 200 of file LpInterface.cpp.

                                                 {
        if (_ileft_ || _iright_)
          GUM_ERROR(OperationNotAllowed, "expr::operator+= (expr) : <= present on one side of expr")

        if (!_imiddle_) _imiddle_ = true;

        _mCoeffs_->getWithDefault(rhs, 0.) += 1.;

        return *this;
      }

operator+=() [2/4]

LpExpr & gum::credal::lp::LpExpr::operator+=

(

const LpExpr &

rhs

)

Compound assignment operator += with another expression.

Parameters

rhs	the constant reference to the expression to add to the calling expression.

Returns

The reference of the calling expression.

Definition at line 211 of file LpInterface.cpp.

                                                  {
        if (_ileft_ || _iright_ || rhs._ileft_ || rhs._iright_)
          GUM_ERROR(OperationNotAllowed,
                    "expr::operator+= (rhs) : <= present "
                    "on one side of rhs and/or expr");

        if (!_imiddle_) _imiddle_ = true;

        for (const auto& elt: *rhs._mCoeffs_)
          _mCoeffs_->getWithDefault(elt.first, 0.) += elt.second;

        _mValue_ += rhs._mValue_;

        return *this;
      }

operator+=() [3/4]

LpExpr & gum::credal::lp::LpExpr::operator+=

(

LpExpr &&

rhs

)

Compound assignment operator += with another temporary expression.

Parameters

rhs	the temporary expression to add to the calling expression.

Returns

The reference of the calling expression.

Definition at line 227 of file LpInterface.cpp.

                                             {
        if (_ileft_ || _iright_ || rhs._ileft_ || rhs._iright_)
          GUM_ERROR(OperationNotAllowed,
                    "expr::operator+= (rhs) : <= present "
                    "on one side of rhs and/or expr");

        if (!_imiddle_) {
          _imiddle_ = true;
          _mValue_  = rhs._mValue_;
          swap(_mCoeffs_, rhs._mCoeffs_);

          return *this;
        }

        for (const auto& elt: *rhs._mCoeffs_)
          _mCoeffs_->getWithDefault(elt.first, 0.) += elt.second;
        _mValue_ += rhs._mValue_;

        return *this;
      }

operator+=() [4/4]

template<typename T >

LpExpr & gum::credal::lp::LpExpr::operator+=

(

const T &

rhs

)

Compound assignment operator += with a scalar.

Template Parameters

SCALAR

A scalar type ( integer or float ( any precision ) ).

Parameters

rhs	the constant reference to the scalar to add to the calling expression.

Returns

The reference of the calling expression.

Definition at line 42 of file LpInterface_tpl.h.

                                             {
        if (_ileft_ || _iright_)
          GUM_ERROR(OperationNotAllowed, "expr::operator+= (expr) : <= present on one side of expr")

        if (!_imiddle_) _imiddle_ = true;

        _mValue_ += rhs;

        return *this;
      }

operator-=() [1/3]

LpExpr & gum::credal::lp::LpExpr::operator-=

(

const LpCol &

rhs

)

Compound assignment operator -= with a variable.

Parameters

rhs	the constant reference to the variable to substract from the calling expression.

Returns

The reference of the calling expression.

Definition at line 248 of file LpInterface.cpp.

                                                 {
        if (_ileft_ || _iright_)
          GUM_ERROR(OperationNotAllowed, "expr::operator-= (rhs) : <= present in one of expr")

        if (!_imiddle_) _imiddle_ = true;

        _mCoeffs_->getWithDefault(rhs, 0.) -= 1.;

        return *this;
      }

operator-=() [2/3]

LpExpr & gum::credal::lp::LpExpr::operator-=

(

const LpExpr &

rhs

)

Compound assignment operator -= with another expression.

Parameters

rhs	the constant reference to the expression to substract from the calling expression.

Returns

The reference of the calling expression.

Definition at line 259 of file LpInterface.cpp.

                                                  {
        if (_ileft_ || _iright_ || rhs._ileft_ || rhs._iright_)
          GUM_ERROR(OperationNotAllowed,
                    "expr::operator-= (rhs) : <= present in one of rhs and/or expr");

        if (!_imiddle_) _imiddle_ = true;

        for (const auto& elt: *rhs._mCoeffs_)
          _mCoeffs_->getWithDefault(elt.first, 0.) -= elt.second;

        _mValue_ -= rhs._mValue_;

        return *this;
      }

operator-=() [3/3]

template<typename T >

LpExpr & gum::credal::lp::LpExpr::operator-=

(

const T &

rhs

)

Compound assignment operator -= with a salar.

Template Parameters

SCALAR

A scalar type ( integer or float ( any precision ) ).

Parameters

rhs	the constant reference to the scalar to substract from the calling expression.

Returns

The reference of the calling expression.

Definition at line 54 of file LpInterface_tpl.h.

                                             {
        if (_ileft_ || _iright_)
          GUM_ERROR(OperationNotAllowed, "expr::operator-= (rhs) : <= present in one of expr")

        if (!_imiddle_) _imiddle_ = true;

        _mValue_ -= rhs;

        return *this;
      }

operator=() [1/4]

LpExpr & gum::credal::lp::LpExpr::operator=

(

const LpCol &

rhs

)

Assignment operator = with a variable.

Parameters

rhs	the constant reference to the variable to form an expression with.

Returns

The address of the calling expression.

Definition at line 152 of file LpInterface.cpp.

                                                {
        clear();

        _mCoeffs_->insert(rhs, 1.);
        _imiddle_ = true;

        return *this;
      }

operator=() [2/4]

LpExpr & gum::credal::lp::LpExpr::operator=

(

const LpExpr &

rhs

)

Assignment operator = with another expression, by copy.

Parameters

rhs	the constant reference to the expression to copy.

Returns

The address of the calling expression.

Definition at line 161 of file LpInterface.cpp.

                                                 {
        if (this == &rhs) return *this;

        *_lCoeffs_ = *rhs._lCoeffs_;
        *_mCoeffs_ = *rhs._mCoeffs_;
        *_rCoeffs_ = *rhs._rCoeffs_;

        _lValue_ = rhs._lValue_;
        _mValue_ = rhs._mValue_;
        _rValue_ = rhs._rValue_;

        _ileft_   = rhs._ileft_;
        _imiddle_ = rhs._imiddle_;
        _iright_  = rhs._iright_;

        return *this;
      }

operator=() [3/4]

LpExpr & gum::credal::lp::LpExpr::operator=

(

LpExpr &&

rhs

)

Assignment operator = with another expression, by move.

Parameters

rhs	the expression to move to this.

Returns

The address of the calling expression.

Definition at line 180 of file LpInterface.cpp.

                                            {
        if (this == &rhs) return *this;

        swap(_lCoeffs_, rhs._lCoeffs_);
        swap(_mCoeffs_, rhs._mCoeffs_);
        swap(_rCoeffs_, rhs._rCoeffs_);

        _lValue_ = rhs._lValue_;
        _mValue_ = rhs._mValue_;
        _rValue_ = rhs._rValue_;

        _ileft_   = rhs._ileft_;
        _imiddle_ = rhs._imiddle_;
        _iright_  = rhs._iright_;

        return *this;
      }

operator=() [4/4]

template<typename SCALAR >

LpExpr & gum::credal::lp::LpExpr::operator=

(

const SCALAR &

rhs

)

Assignment operator = with a scalar.

class LpExpr

Template Parameters

SCALAR

A scalar type ( integer or float ( any precision ) ).

Parameters

rhs	the constant reference to the scalar to form an expression with.

Returns

The address of the calling expression.

Definition at line 32 of file LpInterface_tpl.h.

                                                 {
        clear();

        _mValue_  = rhs;
        _imiddle_ = true;

        return *this;
      }

toString()

std::string gum::credal::lp::LpExpr::toString

(

)

const

Get the string representation of a calling expression.

Returns

The string representation of the calling expression.

Definition at line 476 of file LpInterface.cpp.

                                       {
        std::ostringstream s;

        s << std::endl << "left side : " << std::endl;

        if (_lCoeffs_ != nullptr)
          for (const auto& elt: *_lCoeffs_)
            s << elt.first.toString() << " " << elt.second << " | ";

        s << std::endl << "middle side : " << std::endl;

        if (_mCoeffs_ != nullptr)
          for (const auto& elt: *_mCoeffs_)
            s << elt.first.toString() << " " << elt.second << " | ";

        s << std::endl << "right side : " << std::endl;

        if (_rCoeffs_ != nullptr)
          for (const auto& elt: *_rCoeffs_)
            s << elt.first.toString() << " " << elt.second << " | ";

        s << std::endl
          << "lvalue : " << _lValue_ << std::endl
          << "mvalue : " << _mValue_ << std::endl
          << "rvalue : " << _rValue_ << std::endl;

        s << std::endl;

        return s.str();
      }

Friends And Related Function Documentation

LpInterface

template<typename GUM_SCALAR >

friend class LpInterface

friend

Definition at line 211 of file LpInterface.h.

LpRow

friend class LpRow

friend

Definition at line 209 of file LpInterface.h.

Member Data Documentation

_ileft_

bool gum::credal::lp::LpExpr::_ileft_

private

True if this expression has a non-empty left side L : L <= M <= R .

False otherwise.

Definition at line 413 of file LpInterface.h.

_imiddle_

bool gum::credal::lp::LpExpr::_imiddle_

private

True if this expression has a non-empty middle side M ( the default ) : L <= M <= R .

False otherwise.

Definition at line 417 of file LpInterface.h.

_iright_

bool gum::credal::lp::LpExpr::_iright_

private

True if this expression has a non-empty right side R : L <= M <= R .

False otherwise.

Definition at line 421 of file LpInterface.h.

_lCoeffs_

HashTable< LpCol, double >* gum::credal::lp::LpExpr::_lCoeffs_

private

The coefficients of each variable on the left side L : L <= M <= R.

If a variable is not present, it's coefficient is 0.

Definition at line 433 of file LpInterface.h.

_lValue_

double gum::credal::lp::LpExpr::_lValue_

private

The constant on the left side L : L <= M <= R.

Definition at line 424 of file LpInterface.h.

_mCoeffs_

HashTable< LpCol, double >* gum::credal::lp::LpExpr::_mCoeffs_

private

The coefficients of each variable on the middle side L : L <= M <= R.

If a variable is not present, it's coefficient is 0.

Definition at line 437 of file LpInterface.h.

_mValue_

double gum::credal::lp::LpExpr::_mValue_

private

The constant on the middle side L : L <= M <= R.

Definition at line 426 of file LpInterface.h.

_rCoeffs_

HashTable< LpCol, double >* gum::credal::lp::LpExpr::_rCoeffs_

private

The coefficients of each variable on the right side L : L <= M <= R.

If a variable is not present, it's coefficient is 0.

Definition at line 441 of file LpInterface.h.

_rValue_

double gum::credal::lp::LpExpr::_rValue_

private

The constant on the right side L : L <= M <= R.

Definition at line 428 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
• agrum/CN/polytope/LpInterface_tpl.h