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

Constructor & Destructor Documentation

LpExpr() [1/5]

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

(

)

Default constructor.

class LpExpr

Definition at line 70 of file LpInterface_tpl.h.

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

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, and __rValue.

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

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, __rValue, and gum::credal::lp::swap().

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

Here is the call graph for this function:

~LpExpr()

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

(

)

Default destructor.

Definition at line 165 of file LpInterface_tpl.h.

References __lCoeffs, __mCoeffs, and __rCoeffs.

                      {
        delete __lCoeffs;
        delete __mCoeffs;
        delete __rCoeffs;

        GUM_DESTRUCTOR(LpExpr);
      }

Member Function Documentation

__addSide() [1/4]

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

inlineprivate

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

References __ileft, __imiddle, __iright, __lCoeffs, __mCoeffs, __rCoeffs, and GUM_ERROR.

Referenced by lessThan().

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

Here is the caller graph for this function:

__addSide() [2/4]

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

inlineprivate

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, __rValue, and GUM_ERROR.

                                               {
        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 )

inlineprivate

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, __rValue, GUM_ERROR, and gum::credal::lp::swap().

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

Here is the call graph for this function:

__addSide() [4/4]

template<typename SCALAR >

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

inlineprivate

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

References __ileft, __imiddle, __iright, __lValue, __mValue, __rValue, and GUM_ERROR.

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, and __rValue.

Referenced by operator=().

                         {
        __lCoeffs->clear();
        __mCoeffs->clear();
        __rCoeffs->clear();

        __lValue = 0.;
        __mValue = 0.;
        __rValue = 0.;

        __ileft = false;
        __imiddle = false;
        __iright = false;
      }

Here is the caller graph for this function:

lessThan() [1/2]

template<typename T1 , typename T2 >

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

static

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

Here is the caller graph for this function:

lessThan() [2/2]

template<typename T1 , typename T2 >

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

Definition at line 1172 of file LpInterface_tpl.h.

References __addSide().

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

Here is the call graph for this function:

multiply() [1/2]

template<typename SCALAR >

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

static

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

Here is the caller graph for this function:

multiply() [2/2]

template<typename SCALAR >

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

Definition at line 1153 of file LpInterface_tpl.h.

References __imiddle, and __mCoeffs.

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

References __ileft, __imiddle, __iright, __mCoeffs, and GUM_ERROR.

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

References __ileft, __imiddle, __iright, __mCoeffs, __mValue, and GUM_ERROR.

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

References __ileft, __imiddle, __iright, __mCoeffs, __mValue, GUM_ERROR, and gum::credal::lp::swap().

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

Here is the call graph for this function:

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

References __ileft, __imiddle, __iright, __mValue, and GUM_ERROR.

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

References __ileft, __imiddle, __iright, __mCoeffs, and GUM_ERROR.

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

References __ileft, __imiddle, __iright, __mCoeffs, __mValue, and GUM_ERROR.

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

References __ileft, __imiddle, __iright, __mValue, and GUM_ERROR.

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

References __imiddle, __mCoeffs, and clear().

                                                {
        clear();

        __mCoeffs->insert(rhs, 1.);
        __imiddle = true;

        return *this;
      }

Here is the call graph for this function:

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, and __rValue.

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

References __ileft, __imiddle, __iright, __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, __rValue, and gum::credal::lp::swap().

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

Here is the call graph for this function:

operator=() [4/4]

template<typename SCALAR >

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

(

const SCALAR &

rhs

)

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 form an expression with.

Returns

The address of the calling expression.

Definition at line 221 of file LpInterface_tpl.h.

References __imiddle, __mValue, and clear().

                                                 {
        clear();

        __mValue = rhs;
        __imiddle = true;

        return *this;
      }

Here is the call graph for this function:

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

References __lCoeffs, __lValue, __mCoeffs, __mValue, __rCoeffs, and __rValue.

Referenced by gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), gum::credal::lp::LpRow::LpRow(), and gum::credal::lp::operator<<().

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

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

LpRow

friend class LpRow

friend

Definition at line 211 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 415 of file LpInterface.h.

Referenced by __addSide(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator+=(), operator-=(), and operator=().

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

Referenced by __addSide(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), clear(), LpExpr(), multiply(), operator+=(), operator-=(), and operator=().

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

Referenced by __addSide(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator+=(), operator-=(), and operator=().

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

Referenced by __addSide(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator=(), toString(), and ~LpExpr().

__lValue

double gum::credal::lp::LpExpr::__lValue

private

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

Definition at line 426 of file LpInterface.h.

Referenced by __addSide(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator=(), and toString().

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

Referenced by __addSide(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), multiply(), operator+=(), operator-=(), operator=(), toString(), and ~LpExpr().

__mValue

double gum::credal::lp::LpExpr::__mValue

private

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

Definition at line 428 of file LpInterface.h.

Referenced by __addSide(), gum::credal::lp::LpInterface< GUM_SCALAR >::addRow(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator+=(), operator-=(), operator=(), and toString().

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

Referenced by __addSide(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator=(), toString(), and ~LpExpr().

__rValue

double gum::credal::lp::LpExpr::__rValue

private

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

Definition at line 430 of file LpInterface.h.

Referenced by __addSide(), clear(), LpExpr(), gum::credal::lp::LpRow::LpRow(), operator=(), and toString().

---

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

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