8.2.6. MdoExprLinear¶

class mindopt::MdoExprLinear : public mindopt::MdoExpr ¶

线性表达式对象。

此对象会实现包含线性约束表达式对象的数据结构，此线性约束表达式对象包含一组系数-变量对。

输入线性约束表达式的典型步骤如下：

调用 MdoModel::addVar() 创建一组空变量对象。
调用 MdoExprLinear::MdoExprLinear() 创建一个空线性表达式对象。
使用重载运算符（如 += 或 +）或者成员函数 MdoExprLinear::addTerms() 输入线性表达式。

例如：

MdoVar & x1 = model.addVar();
MdoVar & x2 = model.addVar();
MdoExprLinear expr1;
expr1 = 1 * x1;
expr1 += x2;
MdoVar & x3 = model.addVar();
MdoExprLinear expr2;
expr2 = expr1 + x3;

可通过调用 MdoExprLinear::getVar() 和 MdoCol::getCoeff() 查询非零元素，以访问关联的变量和系数。

Note

一般来说，这是一个有效期很短的临时对象。
一般来说，expr += x``（或 ``expr -= x）比 expr = expr + x 效率高得多，因此在循环指令中应避免使用后者。请注意，构建表达式对象最有效的方法是调用 MdoExprLinear::addTerms()。

示例

/* Create an empty model. */
MdoModel model;

MdoI32 itmp = 0;
MdoReal dtmp = 0.0;

/* Add empty constraints. */
std::vector<std::reference_wrapper<MdoCons> > cons;
cons.push_back(model.addCons(1.0, 1.0,           "c0"));
cons.push_back(model.addCons(1.0, MDO_INFINITY,  "c1"));

/* Input columns. */
std::vector<MdoCol> col(4);
col[0].addTerm(cons[0], 1.0);
col[0].addTerm(cons[1], 1.0);
col[1].addTerm(cons[0], 1.0);
col[2].addTerm(cons[0], 2.0);
col[2].addTerm(cons[1], -1.0);
col[3].addTerm(cons[0], 3.0);
col[3].addTerm(cons[1], 6.0);

/* Add variables. */
std::vector<std::reference_wrapper<MdoVar> > x;
x.push_back(model.addVar(0.0, 10.0,         1.0, col[0], "x0", MDO_NO));
x.push_back(model.addVar(0.0, MDO_INFINITY, 1.0, col[1], "x1", MDO_NO));
x.push_back(model.addVar(0.0, MDO_INFINITY, 1.0, col[2], "x2", MDO_NO));
x.push_back(model.addVar(0.0, MDO_INFINITY, 1.0, col[3], "x3", MDO_NO));

MdoExprLinear c0_expr;
c0_expr = model.getExprLinear(c0);
std::cout << "c0_expr: " << std::endl << c0_expr << std::endl;

/* Check linear expression object */
MdoVar x_tmp = c0_expr.getVar(0);
itmp = x_tmp.sameAs(x0);
dtmp = c0_expr.getCoeff(0);
itmp = c0_expr.getSize();

/* Set/get constant */
dtmp = c0_expr.getConstant();
c0_expr.addConstant(10.0);
dtmp = c0_expr.getConstant();
c0_expr.setConstant(-10.0);
dtmp = c0_expr.getConstant();

/* Remove item from linear expression */
c0_expr.removeTerm(1);
itmp = c0_expr.getSize();
c0_expr.removeTerm(x_tmp);
itmp = c0_expr.getSize();
c0_expr.clear();
itmp = c0_expr.getSize();

/* Adds a set of nonzero terms. */
MdoVar x_array[] = {x[0].get(), x[1].get(), x[2].get(), x[3].get()};

double row_coeff_array[] = {1, 2, 3};
c0_expr.addTerms(x_array, row_coeff_array, 3);

double *row_coeff_chk = new double[3];
int i;
for (i=0; i < 3; i++)
{
    row_coeff_chk[i] = c0_expr.getCoeff(i);
}

/* Adds a nonzero term. */
c0_expr.addTerm(x_array[3], 4.0);
dtmp = c0_expr.getCoeff(3);

构造函数/析构函数。

MdoExprLinear(void)¶: 默认构造函数。

virtual ~MdoExprLinear(void)¶: 析构函数。

MdoExprLinear(const MdoExprLinear &rhs)¶

复制构造函数。

Parameters: rhs – 要复制的对象。

重载运算符。

MdoExprLinear &operator=(const MdoExprLinear &rhs)¶

将当前表达式设置为等于其他表达式。

Parameters: rhs – 其他表达式。
Return: 更新的表达式对象。

MdoExprLinear operator+(const MdoExprLinear &rhs) const¶

将其他表达式添加到当前表达式，并生成新的线性表达式。

Parameters: rhs – 其他表达式。
Return: 等于调用表达式与参数表达式之和的新表达式对象。

MdoExprLinear operator-(const MdoExprLinear &rhs) const¶

用当前表达式减去其他表达式，得到一个新的线性表达式。

Parameters: rhs – 其他表达式。
Return: 等于调用表达式与参数表达式之差的新表达式对象。

MdoExprLinear &operator+=(const MdoExprLinear &rhs)¶

将其他表达式添加到当前表达式。

Parameters: rhs – 其他表达式。
Return: 等于调用表达式与参数表达式之和的更新的表达式对象。

MdoExprLinear &operator-=(const MdoExprLinear &rhs)¶

用当前表达式减去其他表达式。

Parameters: rhs – 其他表达式。
Return: 等于调用表达式与参数表达式之差的更新的表达式对象。

MdoExprLinear &operator+=(const MdoVar &var)¶

将变量添加到当前变量。

Parameters: var – 变量对象。
Return: 等于调用表达式与变量对象之和的更新的表达式对象。

MdoExprLinear &operator-=(constMdoVar &var)¶

用当前表达式减去变量。

Parameters: var – 变量对象。
Return: 等于调用表达式与变量对象之差的更新的表达式对象。

MdoExprLinear &operator+=(const MdoReal constant)¶

将常数项添加到当前常数项。

Parameters: constant – 常数项。
Return: 等于调用表达式与常数项之和的更新的表达式对象。

MdoExprLinear &operator-=(const MdoReal constant)¶

用当前表达式减去常数项。

Parameters: constant – 常数项。
Return: 等于调用表达式与常数项之差的更新的表达式对象。

MdoExprLinear &operator*=(MdoReal scal)¶

用当前表达式乘以常量。

Parameters: scal – 乘数。
Return: 更新的表达式对象。

MdoExprLinear &operator/=(MdoReal scal)¶

用当前表达式除以常量。

Parameters: scal – 除数。
Return: 更新的表达式对象。

用于访问内部数据的函数。

void addTerm(const MdoVar &var, MdoReal coeff)¶

此函数会添加一个非零项。非零变量对象即一对变量和系数。

Parameters

var – 与非零项关联的变量对象。
coeff – 非零项的系数。

void addTerms(const MdoVar *vars, const MdoReal *coeffs, MdoI32 size)¶

此函数会添加一组非零项。非零项就是一对变量和系数。

Parameters

vars – 包含变量对象的数组。
coeffs – 包含非零系数的数组。
size – 待添加的项数。

const MdoVar &getVar(MdoI32 pos) const¶

此函数会从表达式对象中检索变量对象。

Parameters: pos – 当前存储在 pos 位置的项。
Return: 非零系数。

MdoVar &getVar(MdoI32 pos)¶

此函数会从表达式对象中检索变量对象。

Parameters: pos – 当前存储在 pos 位置的项。
Return: 非零系数。

MdoReal getCoeff(MdoI32 pos) const¶

此函数会从表达式对象中检索非零元素的值。

Parameters: pos – 当前存储在 pos 位置的项。
Return: 非零元素的值。

void removeTerm(MdoI32 pos)¶

在给定变量索引的情况下，此函数会从表达式对象中删除一个非零元素。

Parameters: pos – 当前存储在 pos 位置的项。

MdoBool removeTerm(const MdoVar &var)¶

在给定变量对象的情况下，此函数会从表达式对象中删除一个非零元素。

Parameters: var – 将被删除系数的变量对象。
Return: 如果指定的系数存在于表达式中并且已被删除，则返回 true。

MdoReal getConstant(void) const¶

此函数会返回表达式对象中的常数项。

Return: 常数项。

void setConstant(MdoReal constant)¶

此函数会更改表达式对象中的常数项。

Parameters: constant – 新的常数项。

void addConstant(MdoReal constant)¶

此函数会向表达式对象添加常数项。

Parameters: constant – 待添加的常数项。

void clear(void)¶: 此函数会从表达式对象中删除所有非零元素，并将常数项重置为 0.0。

MdoI32 getSize(void) const¶

此函数会检索存储在表达式对象中的非零元素。

Return: 存储在表达式对象中的非零元素数量。