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

Constructor & Destructor Documentation

LpExpr() [1/5]

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

(

)

Default constructor.

class LpExpr

Definition at line 54 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 62 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 72 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 104 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 149 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 283 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 299 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 380 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 68 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 470 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 503 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 484 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 205 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 217 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 233 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 254 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 266 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 55 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 157 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 166 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 185 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 484 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 212 of file LpInterface.h.

LpRow

friend class LpRow

friend

Definition at line 210 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 414 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 418 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 422 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 434 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 425 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 438 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 427 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 442 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 429 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