aGrUM  0.18.1 a C++ library for (probabilistic) graphical models
gum::credal::lp Namespace Reference

namespace for constraint-based description of credal sets More...

## Classes

class  LpCol
Class representing a variable ( a column ) of a linear program, i.e. More...

class  LpExpr
Class representing a linear expression. More...

class  LpInterface
Class representing a linear program. More...

class  LpRow
Class representing a row of the linear program, i.e. More...

## Functions

void swap (HashTable< LpCol, double > *&a, HashTable< LpCol, double > *&b)
Swap the addresses of two pointers to hashTables. More...

std::ostream & operator<< (std::ostream &out, const LpCol &col)

std::ostream & operator<< (std::ostream &out, const LpExpr &expr)

std::ostream & operator<< (std::ostream &out, const LpRow &row)

template<typename T >
std::ostream & operator<< (std::ostream &out, const LpInterface< T > &lpi)

template<typename T2 >
LpExpr operator+ (const LpExpr &lhs, const T2 &rhs)

template<typename T2 >
LpExpr operator- (const LpExpr &lhs, const T2 &rhs)

Non-members operators +
template<typename T2 >
LpExpr operator+ (LpExpr &&lhs, const T2 &rhs)
Overload of operator + between anything ( a scalar, a variable or an expression ) and anything except a temporary expression. More...

template<typename T2 >
LpExpr operator+ (LpExpr &lhs, const T2 &rhs)
Overload of operator + between anything ( a scalar, a variable or an expression ) and anything except a temporary expression. More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
LpExpr operator+ (const T1 &lhs, LpExpr &&rhs)
Overload of operator + between anything ( a scalar, a variable or an expression ) and a temporary expression. More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
LpExpr operator+ (const T1 &lhs, LpExpr &rhs)
Overload of operator + between anything ( a scalar, a variable or an expression ) and anything except a temporary expression. More...

template<typename T2 , forbidden_type< T2, LpExpr > = 0>
LpExpr operator+ (const LpCol &lhs, const T2 &rhs)
operator+ between LpCol lhs and not LpExpr rhs More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
LpExpr operator+ (const T1 &lhs, const LpCol &rhs)
operator+ between neither LpExpr nor LpCol lhs and LpCol rhs More...

Non-members operators -
template<typename T2 >
LpExpr operator- (LpExpr &&lhs, const T2 &rhs)
Overload of operator - between anything ( a scalar, a variable or an expression ) and anything except a temporary expression. More...

template<typename T2 >
LpExpr operator- (LpExpr &lhs, const T2 &rhs)
Overload of operator - between anything ( a scalar, a variable or an expression ) and anything except a temporary expression. More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
LpExpr operator- (const T1 &lhs, LpExpr &&rhs)
Overload of operator - between anything ( a scalar, a variable or an expression ) and a temporary expression. More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
LpExpr operator- (const T1 &lhs, LpExpr &rhs)
Overload of operator - between anything ( a scalar, a variable or an expression ) and anything except a temporary expression. More...

template<typename T2 , forbidden_type< T2, LpExpr > = 0>
LpExpr operator- (const LpCol &lhs, const T2 &rhs)
operator- between LpCol lhs and not LpExpr rhs More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
LpExpr operator- (const T1 &lhs, const LpCol &rhs)
operator- between neither LpExpr nor LpCol lhs and LpCol rhs More...

Non-members operators *
template<typename SCALAR >
LpExpr operator* (const SCALAR &lhs, const LpCol &rhs)
Overload of operator * between a scalar and a variable. More...

template<typename SCALAR >
LpExpr operator* (const LpCol &lhs, const SCALAR &rhs)
Overload of operator * between a variable and a scalar. More...

Non-members operators <=
template<typename T2 >
LpExpr operator<= (const LpExpr &lhs, T2 &&rhs)
Overload of operator <= between anything and anything. More...

template<typename T2 >
LpExpr operator<= (const LpCol &lhs, T2 &&rhs)
Overload of operator <= between anything and anything. More...

template<typename T1 , forbidden_type< T1, LpExpr & > = 0, forbidden_type< T1, LpCol & > = 0>
LpExpr operator<= (T1 &&lhs, const LpExpr &rhs)
Overload of operator <= between anything and anything. More...

template<typename T1 , forbidden_type< T1, LpExpr & > = 0, forbidden_type< T1, LpCol & > = 0>
LpExpr operator<= (T1 &&lhs, const LpCol &rhs)
Overload of operator <= between anything and anything. More...

template<typename T2 >
LpExpr operator<= (LpExpr &&lhs, T2 &&rhs)
Overload of operator <= between anything and anything. More...

template<typename T2 >
LpExpr operator<= (LpCol &&lhs, T2 &&rhs)
Overload of operator <= between anything and anything. More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
LpExpr operator<= (T1 &&lhs, LpExpr &&rhs)
Overload of operator <= between anything and anything. More...

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
LpExpr operator<= (T1 &&lhs, LpCol &&rhs)
Overload of operator <= between anything and anything. More...

## Detailed Description

namespace for constraint-based description of credal sets

## ◆ operator*() [1/2]

template<typename SCALAR >
 LpExpr gum::credal::lp::operator* ( const SCALAR & lhs, const LpCol & rhs )

Overload of operator * between a scalar and a variable.

Parameters
 lhs the constant reference to the scalar on the left hand side of the operator. rhs the constant reference to the variable on the right hand side of the operator.
Template Parameters
 SCALAR A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs * rhs.

Definition at line 1161 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::multiply().

1161  {
1162  return LpExpr::multiply(lhs, rhs);
1163  }
Here is the call graph for this function:
Here is the caller graph for this function:

## ◆ operator*() [2/2]

template<typename SCALAR >
 LpExpr gum::credal::lp::operator* ( const LpCol & lhs, const SCALAR & rhs )

Overload of operator * between a variable and a scalar.

Parameters
 lhs the constant reference to the variable on the left hand side of the operator. rhs the constant reference to the scalar on the right hand side of the operator.
Template Parameters
 SCALAR A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs * rhs.

Definition at line 1166 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::multiply().

1166  {
1167  return LpExpr::multiply(rhs, lhs);
1168  }
Here is the call graph for this function:

## ◆ operator+() [1/7]

template<typename T2 >
 LpExpr gum::credal::lp::operator+ ( LpExpr && lhs, const T2 & rhs )

Overload of operator + between anything ( a scalar, a variable or an expression ) and anything except a temporary expression.

Implements both the copy operator + and move operator + because operator + is implemented on top of operators +=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the rvalue reference to the temporary expression on the right hand side of the operator. rhs the universal reference to either a scalar, a variable or a lvalue expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs + rhs.

Definition at line 1043 of file LpInterface_tpl.h.

1043  {
1044  LpExpr expr = std::move(lhs);
1045  expr += rhs;
1046
1047  return expr;
1048  }

## ◆ operator+() [2/7]

template<typename T2 >
 LpExpr gum::credal::lp::operator+ ( LpExpr & lhs, const T2 & rhs )

Overload of operator + between anything ( a scalar, a variable or an expression ) and anything except a temporary expression.

Implements both the copy operator + and move operator + because operator + is implemented on top of operators +=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the rvalue reference to the temporary expression on the right hand side of the operator. rhs the universal reference to either a scalar, a variable or a lvalue expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs + rhs.

## ◆ operator+() [3/7]

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
 LpExpr gum::credal::lp::operator+ ( const T1 & lhs, LpExpr && rhs )

Overload of operator + between anything ( a scalar, a variable or an expression ) and a temporary expression.

This overload is used because only one side of the operator profit from move operation; the one with a temporary expression. If the expression if on the right hand side, we always add it first to profit from move operation. Otherwise another overload is used.

Implements both the copy operator + and move operator + because operator + is implemented on top of operators +=. Because of template type deduction lhs is a "universal reference", i.e. either an lvalue or an rvalue reference. To force rvalue reference with template deduction one should use const : const T&& lhs : lhs is an rvalue reference and WILL be modified ( not intuitive const ). Therefor std::forward must be used to forward the type of lhs. rhs is an rvalue reference and std::move must be used to forward it's type.

Parameters
 lhs the universal reference to either a scalar, a variable or an expression on the left hand side of the operator. rhs the rvalue reference to the temporary expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Warning
T1 can not be LpExpr (to avoid ambiguity with previous functions)
Returns
An expression which yields the result of lhs + rhs.

Definition at line 1059 of file LpInterface_tpl.h.

1059  {
1060  LpExpr expr = std::move(rhs);
1061  ;
1062  expr += lhs;
1063
1064  return expr;
1065  }

## ◆ operator+() [4/7]

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
 LpExpr gum::credal::lp::operator+ ( const T1 & lhs, LpExpr & rhs )

Overload of operator + between anything ( a scalar, a variable or an expression ) and anything except a temporary expression.

Implements both the copy operator + and move operator + because operator + is implemented on top of operators +=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the rvalue reference to the temporary expression on the right hand side of the operator. rhs the universal reference to either a scalar, a variable or a lvalue expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs + rhs.

Definition at line 1068 of file LpInterface_tpl.h.

1068  {
1069  LpExpr expr(rhs);
1070  expr += lhs;
1071
1072  return expr;
1073  }

## ◆ operator+() [5/7]

template<typename T2 , forbidden_type< T2, LpExpr > = 0>
 LpExpr gum::credal::lp::operator+ ( const LpCol & lhs, const T2 & rhs )

operator+ between LpCol lhs and not LpExpr rhs

Definition at line 1076 of file LpInterface_tpl.h.

1076  {
1077  LpExpr expr;
1078  expr += lhs;
1079  expr += rhs;
1080
1081  return expr;
1082  }

## ◆ operator+() [6/7]

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
 LpExpr gum::credal::lp::operator+ ( const T1 & lhs, const LpCol & rhs )

operator+ between neither LpExpr nor LpCol lhs and LpCol rhs

Definition at line 1087 of file LpInterface_tpl.h.

1087  {
1088  LpExpr expr;
1089  expr += rhs;
1090  expr += lhs;
1091
1092  return expr;
1093  }

## ◆ operator+() [7/7]

template<typename T2 >
 LpExpr gum::credal::lp::operator+ ( const LpExpr & lhs, const T2 & rhs )

Definition at line 1051 of file LpInterface_tpl.h.

1051  {
1052  LpExpr expr(lhs);
1053  expr += rhs;
1054
1055  return expr;
1056  }

## ◆ operator-() [1/7]

template<typename T2 >
 LpExpr gum::credal::lp::operator- ( LpExpr && lhs, const T2 & rhs )

Overload of operator - between anything ( a scalar, a variable or an expression ) and anything except a temporary expression.

Implements both the copy operator - and move operator - because operator - is implemented on top of operators -=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the rvalue reference to the temporary expression on the right hand side of the operator. rhs the universal reference to either a scalar, a variable or a lvalue expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs -rhs.

Definition at line 1097 of file LpInterface_tpl.h.

1097  {
1098  LpExpr expr = std::move(lhs);
1099  expr -= rhs;
1100
1101  return expr;
1102  }

## ◆ operator-() [2/7]

template<typename T2 >
 LpExpr gum::credal::lp::operator- ( LpExpr & lhs, const T2 & rhs )

Overload of operator - between anything ( a scalar, a variable or an expression ) and anything except a temporary expression.

Implements both the copy operator - and move operator - because operator - is implemented on top of operators -=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the rvalue reference to the temporary expression on the right hand side of the operator. rhs the universal reference to either a scalar, a variable or a lvalue expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs -rhs.

## ◆ operator-() [3/7]

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
 LpExpr gum::credal::lp::operator- ( const T1 & lhs, LpExpr && rhs )

Overload of operator - between anything ( a scalar, a variable or an expression ) and a temporary expression.

This overload is used because only one side of the operator profit from move operation; the one with a temporary expression. If the expression if on the right hand side, we always add it first to profit from move operation. Otherwise another overload is used.

Implements both the copy operator - and move operator - because operator - is implemented on top of operators -=. Because of template type deduction lhs is a "universal reference", i.e. either an lvalue or an rvalue reference. To force rvalue reference with template deduction one should use const : const T&& lhs : lhs is an rvalue reference and WILL be modified ( not intuitive const ). Therefor std::forward must be used to forward the type of lhs. rhs is an rvalue reference and std::move must be used to forward it's type.

Parameters
 lhs the universal reference to either a scalar, a variable or an expression on the left hand side of the operator. rhs the rvalue reference to the temporary expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Warning
T1 can not be LpExpr (to avoid ambiguity with previous functions)
Returns
An expression which yields the result of lhs - rhs.

Definition at line 1113 of file LpInterface_tpl.h.

1113  {
1114  LpExpr expr;
1115  expr += std::move(rhs);
1116  ;
1117  expr -= lhs;
1118
1119  return expr;
1120  }

## ◆ operator-() [4/7]

template<typename T1 , forbidden_type< T1, LpExpr > = 0>
 LpExpr gum::credal::lp::operator- ( const T1 & lhs, LpExpr & rhs )

Overload of operator - between anything ( a scalar, a variable or an expression ) and anything except a temporary expression.

Implements both the copy operator - and move operator - because operator - is implemented on top of operators -=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the rvalue reference to the temporary expression on the right hand side of the operator. rhs the universal reference to either a scalar, a variable or a lvalue expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs -rhs.

Definition at line 1123 of file LpInterface_tpl.h.

1123  {
1124  LpExpr expr;
1125  expr += rhs;
1126  expr -= lhs;
1127
1128  return expr;
1129  }

## ◆ operator-() [5/7]

template<typename T2 , forbidden_type< T2, LpExpr > = 0>
 LpExpr gum::credal::lp::operator- ( const LpCol & lhs, const T2 & rhs )

operator- between LpCol lhs and not LpExpr rhs

Parameters
 lhs the universal reference to either a scalar, a variable or an expression on the left hand side of the operator. rhs the rvalue reference to the temporary expression on the right hand side of the operator.
Template Parameters
 T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.

Definition at line 1132 of file LpInterface_tpl.h.

1132  {
1133  LpExpr expr;
1134  expr += lhs;
1135  expr -= rhs;
1136
1137  return expr;
1138  }

## ◆ operator-() [6/7]

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
 LpExpr gum::credal::lp::operator- ( const T1 & lhs, const LpCol & rhs )

operator- between neither LpExpr nor LpCol lhs and LpCol rhs

Parameters
 lhs the universal reference to either a scalar, a variable or an expression on the left hand side of the operator. rhs the rvalue reference to the temporary expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.

Definition at line 1143 of file LpInterface_tpl.h.

1143  {
1144  LpExpr expr;
1145  expr += rhs;
1146  expr -= lhs;
1147
1148  return expr;
1149  }

## ◆ operator-() [7/7]

template<typename T2 >
 LpExpr gum::credal::lp::operator- ( const LpExpr & lhs, const T2 & rhs )

Definition at line 1105 of file LpInterface_tpl.h.

1105  {
1106  LpExpr expr(lhs);
1107  expr -= rhs;
1108
1109  return expr;
1110  }

## ◆ operator<<() [1/4]

 std::ostream& gum::credal::lp::operator<< ( std::ostream & out, const LpCol & col )
Parameters
 out The reference to the caller, i.e. left side of <<. col The constant reference to the variable whose representation we want.
Returns

Definition at line 52 of file LpInterface_tpl.h.

References gum::credal::lp::LpCol::toString().

52  {
53  out << col.toString();
54  return out;
55  }
Here is the call graph for this function:

## ◆ operator<<() [2/4]

 std::ostream& gum::credal::lp::operator<< ( std::ostream & out, const LpExpr & expr )

Definition at line 336 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::toString().

336  {
337  out << expr.toString();
338  return out;
339  }
Here is the call graph for this function:

## ◆ operator<<() [3/4]

 std::ostream& gum::credal::lp::operator<< ( std::ostream & out, const LpRow & row )
Parameters
 out the reference to the caller, i.e. left side of <<. row the constant reference to the row whose representation we want.
Returns

Definition at line 713 of file LpInterface_tpl.h.

References gum::credal::lp::LpRow::toString().

713  {
714  out << row.toString();
715  return out;
716  }
Here is the call graph for this function:

## ◆ operator<<() [4/4]

template<typename T >
 std::ostream& gum::credal::lp::operator<< ( std::ostream & out, const LpInterface< T > & lpi )
Parameters
 out the reference to the caller, i.e. left side of <<. lpi the constant reference to the linear program whose representation we want.
Returns

Definition at line 820 of file LpInterface_tpl.h.

820  {
821  out << lpi.toString();
822  return out;
823  }

## ◆ operator<=() [1/8]

template<typename T2 >
 LpExpr gum::credal::lp::operator<= ( const LpExpr & lhs, T2 && rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1181 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1181  {
1182  return LpExpr::lessThan(lhs, std::forward< T2 >(rhs));
1183  }
Here is the call graph for this function:

## ◆ operator<=() [2/8]

template<typename T2 >
 LpExpr gum::credal::lp::operator<= ( const LpCol & lhs, T2 && rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1186 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1186  {
1187  return LpExpr::lessThan(lhs, std::forward< T2 >(rhs));
1188  }
Here is the call graph for this function:

## ◆ operator<=() [3/8]

template<typename T1 , forbidden_type< T1, LpExpr & > = 0, forbidden_type< T1, LpCol & > = 0>
 LpExpr gum::credal::lp::operator<= ( T1 && lhs, const LpExpr & rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1193 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1193  {
1194  return LpExpr::lessThan(std::forward< T1 >(lhs), rhs);
1195  }
Here is the call graph for this function:

## ◆ operator<=() [4/8]

template<typename T1 , forbidden_type< T1, LpExpr & > = 0, forbidden_type< T1, LpCol & > = 0>
 LpExpr gum::credal::lp::operator<= ( T1 && lhs, const LpCol & rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1200 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1200  {
1201  return LpExpr::lessThan(std::forward< T1 >(lhs), rhs);
1202  }
Here is the call graph for this function:

## ◆ operator<=() [5/8]

template<typename T2 >
 LpExpr gum::credal::lp::operator<= ( LpExpr && lhs, T2 && rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1206 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1206  {
1207  return LpExpr::lessThan(std::move(lhs), std::forward< T2 >(rhs));
1208  }
Here is the call graph for this function:

## ◆ operator<=() [6/8]

template<typename T2 >
 LpExpr gum::credal::lp::operator<= ( LpCol && lhs, T2 && rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1211 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1211  {
1212  return LpExpr::lessThan(std::move(lhs), std::forward< T2 >(rhs));
1213  }
Here is the call graph for this function:

## ◆ operator<=() [7/8]

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
 LpExpr gum::credal::lp::operator<= ( T1 && lhs, LpExpr && rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1218 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1218  {
1219  return LpExpr::lessThan(std::forward< T1 >(lhs), std::move(rhs));
1220  }
Here is the call graph for this function:

## ◆ operator<=() [8/8]

template<typename T1 , forbidden_type< T1, LpExpr > = 0, forbidden_type< T1, LpCol > = 0>
 LpExpr gum::credal::lp::operator<= ( T1 && lhs, LpCol && rhs )

Overload of operator <= between anything and anything.

Implements both the copy operator <= and move operator <=. Because of template type deduction both lhs and rhs are "universal references", i.e. either an lvalue or an rvalue reference. Therefor std::forward must be used to forward the type of lhs and rhs.

Parameters
 lhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the left hand side of the operator. rhs the universal reference to either a ( temporary ) scalar, a ( temporary ) variable or a ( temporary ) expression on the right hand side of the operator.
Template Parameters
 T1 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr. T2 A scalar type ( integer or float ( any precision ) ) or a LpCol or a LpExpr.
Returns
An expression which yields the result of lhs <= rhs.

Definition at line 1225 of file LpInterface_tpl.h.

References gum::credal::lp::LpExpr::lessThan().

1225  {
1226  return LpExpr::lessThan(std::forward< T1 >(lhs), std::move(rhs));
1227  }
Here is the call graph for this function:

## ◆ swap()

 void gum::credal::lp::swap ( HashTable< LpCol, double > *& a, HashTable< LpCol, double > *& b )
inline

Swap the addresses of two pointers to hashTables.

Used by move operations as the temporary will take care of the delete operations.

Warning
DO NOT call this directly ( one of the object owning a pointer must be a temporary, i.e. an "rvalue reference" ).
Parameters
 a the address of the first pointer. b the address of the second pointer.

Definition at line 1035 of file LpInterface_tpl.h.

1035  {
1036  HashTable< LpCol, double >* tmp(a);
1037  a = b;
1038  b = tmp;
1039  }
Here is the caller graph for this function: