8.2.7. MdoModel¶

class mindopt::MdoModel¶

一个可定义优化模型的对象。

此对象会实现包含优化模型的数据结构。

将列输入优化模型的典型步骤如下：

调用 MdoModel::addVar() 创建一组空变量对象。
指定变量的下界、上界和目标系数。
调用 MdoExprLinear::MdoExprLinear() 创建一个空线性表达式对象。
通过调用 MdoModel::addCons() 输入约束。
通过调用 MdoModel::solveProb() 优化问题。

示例

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

MdoI32 itmp = 0;
MdoReal dtmp = 0.0;
std::string ctmp;

model.setDebug(MDO_YES);
btmp = model.isDebug();

/* Change to minimization problem. */
model.setIntAttr("MinSense", MDO_YES);

/* 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));

/* Set obj offset. */
model.setObjOffset(10.0);

/* Solve the problem and check the result. */
model.solveProb();
model.displayResults();

/* Write problem and solution */
model.writeProb(MY_FOLDER "model.lp");
model.writeSoln(MY_FOLDER "model.bas");
model.writeSoln(MY_FOLDER "model.sol");

/* Check Solution */
status = model.getStatus();
std::string status_reason = model.explainStatus(status);

dtmp = model.getRealAttr("PrimalObjVal");
dtmp = model.getRealAttr("DualObjVal");
itmp = model.getIntAttr("HasSolution");
itmp = model.getIntAttr("HasPrimalRay");
dtmp = model.getRealAttrIndex("PrimalSoln", 3);
dtmp = model.getRealAttr("SolutionTime");

std::vector<double> primal_soln_array = model.getRealAttrArray("PrimalSoln", 0, 4);
dtmp = x[3].get().getRealAttr("PrimalSoln");
dtmp = model.getRealAttrIndex("DualSoln", 0);
std::vector<double> dual_soln_array = model.getRealAttrArray("DualSoln", 0, 2);
dtmp = cons[0].get().getRealAttr("DualSoln");
itmp = model.getIntAttr("SPX/NumIters");
itmp = model.getIntAttr("IPM/NumIters");

dtmp = model.getRealAttrIndex("Activity", 0);
std::vector<double> activity_array = model.getRealAttrArray("Activity", 0, 2);
dtmp = cons[1].get().getRealAttr("Activity");
dtmp = model.getRealAttrIndex("ReducedCost", 0);
std::vector<double> reduced_cost_array = model.getRealAttrArray("ReducedCost", 0, 4);
dtmp = x[2].get().getRealAttr("ReducedCost");
std::vector<double> reduced_cost_array_2 = model.getRealAttrVars("ReducedCost", x);

/* Basis */
std::vector<int> col_basis;
std::vector<int> row_basis;
for (auto col : x)
{
    col_basis.push_back(col.get().getIntAttr("ColBasis"));
}
for (auto row : cons)
{
    row_basis.push_back(row.get().getIntAttr("RowBasis"));
}
std::vector<int> col_basis_array = model.getIntAttrArray("ColBasis", 0, 4);
std::vector<int> row_basis_array = model.getIntAttrArray("RowBasis", 0, 2);

std::vector<std::reference_wrapper<MdoVar> > col_vec;
std::vector<std::reference_wrapper<MdoCons> > row_vec;
col_vec.push_back(model.getVar(0));
col_vec.push_back(model.getVar(1));
row_vec.push_back(model.getCons(0));
row_vec.push_back(model.getCons(1));

const int col_basis_chk_2[] = {1, 1};
const int row_basis_chk_2[] = {1, 2};
model.setIntAttrVars("ColBasis", col_vec, col_basis_chk_2);
std::vector<int> col_basis_vec = model.getIntAttrVars("ColBasis", col_vec);
model.setIntAttrConss("RowBasis", row_vec, row_basis_chk_2);
std::vector<int> row_basis_vec = model.getIntAttrConss("RowBasis", row_vec);


/* Change the model */
std::vector<double> objs = model.getObjs(x);
model.setObjs(x, objs);
model.setMaxObjSense();
btmp = model.isMaxObjSense();
model.setMinObjSense();
btmp = model.isMinObjSense();
model.setObjOffset(10.0);
dtmp = model.getObjOffset();

const double col_ub_chk_2[] = {1.0, 2.0};
const double row_rhs_chk_2[] = {3.0, 4.0};
model.setRealAttrVars("UB", col_vec, col_ub_chk_2);
std::vector<double> col_ub_vec = model.getRealAttrVars("UB", col_vec);
model.setRealAttrConss("RHS", row_vec, row_rhs_chk_2);
std::vector<double> row_rhs_vec = model.getRealAttrConss("RHS", row_vec);


/* Model Attributes */
model.setIntAttr("MinSense", 1);
itmp = model.getIntAttr("MinSense");
model.setRealAttr("ObjConst", 1.0);
dtmp = model.getRealAttr("ObjConst");
itmp = model.getIntAttr("NumVars");
itmp = model.getIntAttr("NumConss");
itmp = model.getIntAttr("NumEnts");

model.setRealAttrIndex("LB", 0, -10.0);
dtmp = model.getRealAttrIndex("LB", 0);
double lb_array_chk[4] = {-1, -2, -3, -4};
model.setRealAttrArray("LB", 0, 4, lb_array_chk);
std::vector<double> lb_array = model.getRealAttrArray("LB", 0, 4);
x[3].get().setRealAttr("LB", -10.0);
dtmp = x[3].get().getRealAttr("LB");

model.setRealAttrIndex("UB", 0, +10.0);
dtmp = model.getRealAttrIndex("UB", 0);
double ub_array_chk[4] = {1, 2, 3, 4};
model.setRealAttrArray("UB", 0, 4, ub_array_chk);
std::vector<double> ub_array = model.getRealAttrArray("UB", 0, 4);
x[3].get().setRealAttr("UB", +10.0);
dtmp = x[3].get().getRealAttr("UB");

model.setRealAttrIndex("Obj", 0, +100.0);
dtmp = model.getRealAttrIndex("Obj", 0);
double obj_array_chk[4] = {100, 200, 300, 400};
model.setRealAttrArray("Obj", 0, 4, obj_array_chk);
std::vector<double> obj_array = model.getRealAttrArray("Obj", 0, 4);
x[2].get().setRealAttr("Obj", +100);
dtmp = x[2].get().getRealAttr("Obj");

model.setRealAttrIndex("LHS", 0, -10.0);
dtmp = model.getRealAttrIndex("LHS", 0);
double lhs_array_chk[2] = {-1, -2};
model.setRealAttrArray("LHS", 0, 2, lhs_array_chk);
std::vector<double> lhs_array = model.getRealAttrArray("LHS", 0, 2);
cons[1].get().setRealAttr("LHS", -5.0);
dtmp = cons[1].get().getRealAttr("LHS");

model.setRealAttrIndex("RHS", 0, +10.0);
dtmp =  model.getRealAttrIndex("RHS", 0);
double rhs_array_chk[2] = {1, 2};
model.setRealAttrArray("RHS", 0, 2, rhs_array_chk);
std::vector<double> rhs_array = model.getRealAttrArray("RHS", 0, 2);
cons[1].get().setRealAttr("RHS", 5.0);
dtmp = cons[1].get().getRealAttr("RHS");

std::string col_name = "col_name";
model.setStrAttrIndex("ColName", 0, col_name);
ctmp = model.getStrAttrIndex("ColName", 0);
col_name = "col_name2";
x[1].get().setStrAttr("ColName", col_name);
ctmp = x[1].get().getStrAttr("ColName");

std::string row_name = "row_name";
model.setStrAttrIndex("RowName", 0, row_name);
ctmp = model.getStrAttrIndex("RowName", 0);
row_name = "row_name2";
cons[1].get().setStrAttr("RowName", row_name);
ctmp = cons[1].get().getStrAttr("RowName");

model.setIntAttrIndex("IsInteger", 0, 1);
itmp = model.getIntAttrIndex("IsInteger", 0);
int is_integer_chk[4] = {1, 1, 1, 1};
model.setIntAttrArray("IsInteger", 0, 4, is_integer_chk);
std::vector<int> is_integer_array = model.getIntAttrArray("IsInteger", 0, 4);
x[1].get().setIntAttr("IsInteger", 0);
itmp = x[1].get().getIntAttr("IsInteger");


/* Change elements */
std::vector<std::reference_wrapper<MdoCons> > row_elements;
std::vector<std::reference_wrapper<MdoVar> > col_elements;
std::vector<double> value_elements;
int row_indices[] =
{
    0,   0,   0,   0,
    1,        1,   1
};
int col_indices[] =
{
    0,   1,   2,   3,
    0,        2,   3
};
const double elements_value[] =
{
    1.0, 2.0,  3.0,  4.0,
    -1.0,      -2.0, -3.0
};
for (int i = 0 ; i < 7; i++ )
{
    row_elements.push_back(model.getCons(row_indices[i]));
    col_elements.push_back(model.getVar(col_indices[i]));
    value_elements.push_back(elements_value[i]);
}
model.setElements(row_elements, col_elements, value_elements);
std::vector<double> elements_chk = model.getElements(row_elements, col_elements);


/* Model deletions */
itmp = model.getIntAttr("NumEnts");
std::cout << "NumEnts:" << itmp << std::endl;
std::vector<std::reference_wrapper<MdoCons> > cons_del;
std::vector<std::reference_wrapper<MdoVar> > vars_del;
cons_del.push_back(model.getCons(0));
vars_del.push_back(x[0].get());

model.deleteElements(cons_del, vars_del);
itmp = model.getIntAttr("NumEnts");
std::cout << "NumEnts:" << itmp << std::endl;
model.deleteConss(cons);
itmp = model.getIntAttr("NumConss");
std::cout << "NumConss:" << itmp << std::endl;
model.deleteVars(x);
itmp = model.getIntAttr("NumVars");
std::cout << "NumVars:" << itmp << std::endl;

构造函数/析构函数

MdoModel(void)¶

默认构造函数。

带参数的构造函数。

~MdoModel(void)¶: 析构函数。

MdoModel(const MdoModel &rhs)¶

复制构造函数，复制模型。

Parameters: rhs – 要复制的对象。

基本帮助程序

void freeData(int type = 0)¶

清理所有内部数据。

Parameters: type – [i] 0：默认（两者）；1：仅限行；2：仅限列。

void loadData(int type = 0)¶

加载到内部数据。

Parameters: type – [i] 0：默认（两者）；1：仅限行；2：仅限列。

void syncData(int type = 0)¶

同步内部数据。

Parameters: type – [i] 0：默认（两者）；1：仅限行；2：仅限列。

MdoModel &operator=(const MdoModel &rhs)¶

赋值运算符。

Parameters: rhs – 要复制的对象。
Return: 已更新的对象。

创建/删除变量或约束的方法。

MdoVar &addVar(MdoReal lb, MdoReal ub, MdoReal obj, std::string name = "", bool is_integer = false)¶

此函数会向模型中添加新变量（列）。

Parameters

lb – 下界值。
ub – 上界值。
obj – 目标系数。
name – 变量名称，可以为空。
is_integer – 一个可指定是否为整数变量的标志。

Return

新变量对象。

MdoVar &addVar(MdoReal lb, MdoReal ub, MdoReal obj, const MdoCol &col, std::string name = "", bool is_integer = false)¶

此函数会向模型中添加新变量（列）。

Parameters

lb – 下界值。
ub – 上界值。
obj – 目标系数。
col – 包含非零元素的列对象。
name – 变量名称，可以为空。
is_integer – 一个可指定是否为整数变量的标志。

Return

新变量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, const bool *are_integers, const std::string *names)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。
names – 变量名称数组。如果为 NULL，则将使用默认名称。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, const bool *are_integers, std::string name_prefix)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。
name_prefix – 变量名称的前缀部分。如果为空，则将使用默认名称。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, MdoReallb, MdoReal ub, MdoReal obj, const std::string *names, const bool *are_integers)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
lb – 所有新变量的下界值。
ub – 所有新变量的上界值。
obj – 所有新变量的目标系数值。
names – 变量名称数组。如果为 NULL，则将使用默认名称。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, MdoReal lb, MdoReal ub, MdoReal obj, std::string name_prefix, const bool *are_integers)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
lb – 所有新变量的下界值。
ub – 所有新变量的上界值。
obj – 所有新变量的目标系数值。
name_prefix – 变量名称的前缀部分。如果为空，则将使用默认名称。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, const MdoReal *lbs, const MdoReal *ubs, const MdoReal *objs, const std::string *names, const bool *are_integers)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
lbs – 新变量的下界数组。如果为 NULL，则 0.0 值将用于所有下界。
ubs – 上界数组。如果为 NULL，则无穷值将用于所有上界。
objs – 目标系数数组。如果为 NULL，则 0.0 值将用于所有目标系数。
names – 变量名称数组。如果为 NULL，则将使用默认名称。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, const MdoReal *lbs, const MdoReal *ubs, const MdoReal *objs, std::string name_prefix, const bool *are_integers)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
lbs – 新变量的下界数组。如果为 NULL，则 0.0 值将用于所有下界。
ubs – 上界数组。如果为 NULL，则无穷值将用于所有上界。
objs – 目标系数数组。如果为 NULL，则 0.0 值将用于所有目标系数。
name_prefix – 变量名称的前缀部分。如果为空，则将使用默认名称。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, const MdoReal *lbs, const MdoReal *ubs, const MdoReal *objs, const MdoCol *cols, const std::string *names, const bool *are_integers)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
lbs – 新变量的下界数组。如果为 NULL，则 0.0 值将用于所有下界。
ubs – 上界数组。如果为 NULL，则无穷值将用于所有上界。
objs – 目标系数数组。如果为 NULL，则 0.0 值将用于所有目标系数。
cols – 包含非零元素的列对象数组。如果为 NULL，则所有添加的列都将视为空。
names – 变量名称数组。如果为 NULL，则将使用默认名称。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。

Return

包含对变量对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoVar>> addVars(MdoI32 num_vars, const MdoReal *lbs, const MdoReal *ubs, const MdoReal *objs, const MdoCol *cols, std::string name_prefix, const bool *are_integers)¶

此函数会向模型中添加一组新变量（列）。

Parameters

num_vars – 待添加的变量数。
lbs – 新变量的下界数组。如果为 NULL，则 0.0 值将用于所有下界。
ubs – 上界数组。如果为 NULL，则无穷值将用于所有上界。
objs – 目标系数数组。如果为 NULL，则 0.0 值将用于所有目标系数。
cols – 包含非零元素的列对象数组。如果为 NULL，则所有添加的列都将视为空。
name_prefix – 变量名称的前缀部分。如果为空，则将使用默认名称。
are_integers – 一个可指定变量类型的标志数组。如果为 NULL，则所有变量都将视为连续变量。

Return

包含对变量对象的引用的矢量对象。

MdoCons &addCons(MdoReal lhs, MdoReal rhs, std::string name = "")¶

此函数会向模型中添加新线性约束。

Parameters

lhs – 左侧值。
rhs – 右侧值。
name – 变量名称，可以为空。

Return

新约束对象。

MdoCons &addCons(MdoReal lhs, MdoReal rhs, const MdoExprLinear &expr, std::string name = "")¶

此函数会向模型中添加新线性约束。

Parameters

lhs – 左侧值。
rhs – 右侧值。
expr – 包含新线性约束的表达式对象。
name – 变量名称，可以为空。

Return

新约束对象。

MdoCons &addCons(const MdoTempLinear &temp, std::string name = "")¶

此函数会向模型中添加新线性约束。

Parameters

temp – 包含新线性约束的临时对象。
name – 变量名称，可以为空。

Return

新约束对象。

std::vector<std::reference_wrapper<MdoCons>> addConss(MdoI32 num_conss, const MdoReal *lhss, const MdoReal *rhss, const std::string *names)¶

此函数会向模型中添加一组新线性约束。

Parameters

num_conss – 待添加的约束数。
lhss – 左侧值数组。
rhss – 右侧值数组。
names – 约束名称数组。如果为 NULL，则将使用默认名称。

Return

包含对约束对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoCons>> addConss(MdoI32 num_conss, const MdoReal *lhss, const MdoReal *rhss, std::string name_prefix)¶

此函数会向模型中添加一组新线性约束。

Parameters

num_conss – 待添加的约束数。
lhss – 左侧值数组。
rhss – 右侧值数组。
name_prefix – 约束名称的前缀部分。如果为空，则将使用默认名称。

Return

包含对约束对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoCons>> addConss(MdoI32 num_conss, const MdoReal *lhss, const MdoReal *rhss, const MdoExprLinear *exprs, const std::string *names)¶

此函数会向模型中添加一组新线性约束。

Parameters

num_conss – 待添加的约束数。
lhss – 左侧值数组。
rhss – 右侧值数组。
exprs – 包含新线性约束的表达式对象数组。如果为 NULL，则所有添加的约束都将视为空。
names – 约束名称数组。如果为 NULL，则将使用默认名称。

Return

包含对约束对象的引用的矢量对象。

std::vector<std::reference_wrapper<MdoCons>> addConss(MdoI32 num_conss, const MdoReal *lhss, const MdoReal *rhss, const MdoExprLinear *exprs, std::string name_prefix)¶

此函数会向模型中添加一组新线性约束。

Parameters

num_conss – 待添加的约束数。
lhss – 左侧值数组。
rhss – 右侧值数组。
exprs – 包含新线性约束的表达式对象数组。如果为 NULL，则所有添加的约束都将视为空。
name_prefix – 约束名称的前缀部分。如果为空，则将使用默认名称。

Return

包含对约束对象的引用的矢量对象。

void deleteVars(std::vector<std::reference_wrapper<MdoVar>> &vars)¶

此函数会从模型中删除一组列。

Parameters: vars – 包含对变量的引用的矢量对象。

void deleteConss(std::vector<std::reference_wrapper<MdoCons>> &conss)¶

此函数会从模型中删除一组行。

Parameters: conss – 包含对约束的引用的矢量对象。
Return: 一个可指定函数状态的响应代码。

与半正定矩阵变量相关的方法。

void addSymMat(MdoI32 dim_mat, std::string mat_name = "")¶

此函数会向模型添加块变量（对称半正定矩阵）。

Param dim_mat: 维数(块变量的行数)。
Param mat_name: 块变量名，可以为 NULL.

void addSymMats(MdoI32 num_mats, const MdoI32 *dim_mats, const std::string *mat_names = NULL)¶: 此函数会向模型添加多个块变量。

Param num_mats: 待添加的块变量的个数。
Param dim_mats: 一个包含每个块变量的维数的数组。
Param mat_names: 一个保存块变量名称的数组，如果是``NULL``，默认值将被使用。

void replaceSymMatObjs(const MdoI32 mat_index, MdoI32 size, const MdoI32 *mat_row_indices, const MdoI32 *mat_col_indices, const MdoReal *mat_values)¶: 此函数会替换目标函数中指定块变量。

Param mat_index: 需要替换的块变量索引。
Param size: 要替换的块变量的元素个数。
Param mat_row_indices: 一个保存块变量的行索引的数组。
Param mat_col_indices: 一个保存块变量的列索引的数组。
Param mat_values: 一个保存块变量相关联的元素值的数组。

Note

如果 mat_row_indices[e] \(\neq\) mat_col_indices[e]，那么为了保证矩阵的对称性，矩阵 (mat_row_indices[e]，mat_col_indices[e]) 及 (mat_col_indices[e]，mat_row_indices[e])位置上的值均被改为 mat_values[e]。因此，用户应该只输入块变量的上三角或者下三角部分。

void replaceSymMatElements(MdoI32 row_index, MdoI32 mat_index, MdoI32 size, const MdoI32 *mat_row_indices, const MdoI32 *mat_col_indices, const MdoReal *mat_values)¶: 此函数会替换约束中指定块变量。

Param row_index: 约束行索引。
Param mat_index: 块变量索引。
Param size: 要替换的块变量的元素个数。
Param mat_row_indices: 一个保存块变量的行索引的数组。
Param mat_col_indices: 一个保存块变量的列索引的数组。
Param mat_values: 一个保存与块变量相关联的元素值的数组。

Note

如果 mat_row_indices[e] \(\neq\) mat_col_indices[e]，那么为了保证矩阵的对称性，矩阵 (mat_row_indices[e]，mat_col_indices[e]) 及 (mat_col_indices[e]，mat_row_indices[e])位置上的值均被改为 mat_values[e]。因此，用户应该只输入块变量的上三角或者下三角部分。

std::vector<std::reference_wrapper<MdoReal>> getRealAttrSymMat(std::string att, MdoI32 mat_index, MdoI32 size, const MdoI32 *mat_row_indices, const MdoI32 *mat_col_indices)¶: 此函数会检索与指定块变量属性相关联的值。

Param att: 要访问的实值对称变量属性。
Param mat_index: 块变量索引。
Param size: 要访问的块变量的元素个数。
Param mat_row_indices: 一个保存块变量的行索引的数组。
Param mat_col_indices: 一个保存块变量的列索引的数组。
Retrun: 一个保存与指定块变量属性相关联的值的向量对象。

Note

如果 size 大于或等于指定块矩阵中的元素个数，则将访问指定块矩阵中的所有元素。因此，mat_row_indices 和 mat_col_indices 将不会被访问。

与目标函数相关的方法。

MdoBool isMinObjSense(void) const¶

此函数会检查目标函数是否具有最小化指向。

Return: 一个可指定目标函数是否拥有最小化指向的布尔标志。

MdoBool isMaxObjSense(void) const¶

此函数会检查目标函数是否具有最大化指向。

Return: 一个可指定目标函数是否拥有最大化指向的布尔标志。

void setMinObjSense(void)¶: 此函数会将已加载问题的目标函数更改为最小化指向。

void setMaxObjSense(void)¶: 此函数会将已加载问题的目标函数更改为最大化指向。

MdoReal getObjOffset(void) const¶

此函数会检索目标偏移量（常数项）。

Return: 目标偏移量（常数项）的值。

void setObjOffset(MdoReal obj_fix)¶

此函数会检索目标偏移量（常数项）。

Parameters: obj_fix – 新的目标偏移量（固定成本）。

std::vector<MdoReal> getObjs(std::vector<std::reference_wrapper<MdoVar>> &vars)¶

此函数会检索指定目标系数的值。

Parameters: vars – 包含对待访问变量的引用的矢量对象。
Return: 包含指定目标系数值的 STL 矢量。

void setObjs(std::vector<std::reference_wrapper<MdoVar>> &vars, const MdoReal *vals)¶

此函数会更改目标系数的值。

Parameters

vars – 包含对待访问变量的引用的矢量对象。
vals – 指定目标系数的新值。

行/列查询的方法。

MdoCol getCol(const MdoVar &var) const¶

此函数会检索包含一组约束和系数对的列对象。

Parameters: var – 对变量对象的引用。
Return: 包含一组约束和系数对的列对象。

MdoExprLinear getExprLinear(const MdoCons &cons) const¶

此函数会检索包含一组变量和系数对的线性表达式对象。

Parameters: cons – 对约束对象的引用。
Return: 包含一组变量和系数对的线性表达式对象。

与约束矩阵中的非零元素相关的方法。

std::vector<MdoReal> getElements(const std::vector<std::reference_wrapper<MdoCons>> &conss, const std::vector<std::reference_wrapper<MdoVar>> &vars) const¶

此函数会返回包含约束矩阵中所有指定元素的非零值的矢量对象。

Parameters

conss – 包含对约束的引用的矢量对象。
vars – 包含对变量的引用的矢量对象。

Return

包含约束矩阵中所有指定元素的非零值的矢量对象。

void setElements(const std::vector<std::reference_wrapper<MdoCons>> &conss, const std::vector<std::reference_wrapper<MdoVar>> &vars, const std::vector<MdoReal> &values)¶

此函数会修改约束矩阵中所有指定元素值的集合。

Parameters

conss – 包含对约束的引用的矢量对象。
vars – 包含对变量的引用的矢量对象。
values – 包含约束矩阵中每个指定元素的新非零值的数组。

void setQuadraticElements(const std::vector<std::reference_wrapper<MdoVar>> &vars1, const std::vector<std::reference_wrapper<MdoVar>> &vars2, const std::vector<MdoReal> &values)¶

此函数会修改二次规划的二次项矩阵中所有指定元素值的集合。

Parameters

vars1 – 包含对第一批变量的引用的矢量对象。
vars2 – 包含对第二批变量的引用的矢量对象。
values – 包含新非零值的数组。

void deleteElements(const std::vector<std::reference_wrapper<MdoCons>> &conss, const std::vector<std::reference_wrapper<MdoVar>> &vars)¶

此函数会删除约束矩阵中的一组元素。

Parameters

conss – 包含对约束的引用的矢量对象。
vars – 包含对变量的引用的矢量对象。

void deleteAllElements(void)¶: 此函数会删除约束矩阵中的所有元素。

void deleteAllQuadraticElements(void)¶: 此函数会删除二次规划的二次项矩阵中的所有元素。

void relaxIntegrality(void)¶: 该函数会删除模型中所有整数值的要求，并将其转化为连续松弛问题。

基本 IO。

void readProb(std::string filename)¶

此函数会从文件中读取优化问题。

Parameters: filename – 一个可指定待读取的文件名的字符串。

Note

请注意，已输入模型的类型由文件后缀决定。有效后缀为 .mps(.bz2/.gz) 或 .lp(.bz2/.gz) 或 .dat-s 。
在该函数被调用后，之前加载的问题将被丢弃。
用户可以使用 getConss() (resp. getVars()) 来检索所有创建的约束对象 (resp. variable objects)。

void writeProb(std::string filename) const¶

此函数会向文件写入优化问题。

Parameters: filename – 一个可指定输出文件名的字符串。

Note

请注意，写的优化问题文件类型由文件后缀决定。有效后缀为 .mps ( .bz2/.gz ) 或 .lp ( .bz2/.gz )。

void writeSoln(std::string filename) const¶

此函数会向文件写入最优解。

Parameters: filename – 一个可指定输出文件名的字符串。

Note

请注意，最优解的类型由文件后缀决定。有效后缀为 .sol 或 .bas。

void readTask(std::string filename, bool read_model = true, bool read_param = true, bool read_soln = true)¶

此函数会从文件中读取优化模型任务。

Parameters

filename – 一个可指定输出文件名的字符串。
read_model – 一个可指定是否应加载模型的布尔标志。默认值为 true。
read_param – 一个可指定是否应加载参数的布尔标志。默认值为 true。
read_soln – 一个可指定是否应加载解的布尔标志。默认值为 true。

See

writeTask()

Note

在该函数被调用后，之前加载的问题将被丢弃。
用户可使用 getConss (resp. getVars) 来检索所有创建的约束对象 (resp. variable objects)。
模型任务文件包括问题数据、参数设置和二进制格式的解。

void writeTask(std::string filename, bool write_model = true, bool write_param = true, bool write_soln = true)¶

此函数会将优化任务写入文件。

Parameters

filename – 一个可指定文件名的字符串。
write_model – 一个可指定是否应输出模型的布尔标志。默认值为 true。
write_param – 一个可指定是否应输出参数的布尔标志。默认值为 true。
write_soln – 一个可指定是否应输出解的布尔标志。默认值为 true。

See

readTask()

Note

模型任务文件包括问题数据、参数设置和二进制格式的解。

std::string submitTask(void)¶

此函数会将优化模型任务提交至远程服务器以供优化。

Return: 一个可指定已提交作业 ID 的 STL 字符串。用户可使用此作业 ID 查询优化结果。
See: retrieveTask()

Note

模型任务文件包括问题数据、参数设置和二进制格式的解。
必须先指定远程服务器的令牌 ID 和地址，然后再调用此 API 函数。

std::string retrieveTask(std::string job_id, MdoStatus &code, MdoResult &result, MdoBool &has_soln)¶

查看已提交任务的状态，然后检索相应的优化结果（如有）。所有可能的状态值为：“Submitted”、“Solving”、“Canceled”、“Finished”和“Failed”。

Parameters

job_id – 作业 ID。
code – 一个可指定模型状态的状态代码。
result – 一个可指定优化结果的响应代码，即在远程服务器上调用 Mdo_solveProb 时的响应代码。
has_soln – 一个可指定解的可用性的标志。如果为 true，则用户可以使用 Mdo_readTask 读取已保存至指定位置的解文件。

Return

包含已提交任务状态的 STL 字符串对象。

See

submitTask()

Note

请注意，只有在已提交的任务处于“Finished”状态时，才会返回优化结果。
必须先指定远程服务器的令牌 ID 和地址，然后再调用此 API 函数。

使用属性访问内部数据的方法。

void setStrAttrIndex(std::string att, MdoI32 idx, std::string val)¶

此函数会更改字符串值行/列属性的值。

Parameters

att – 待访问的字符串值模型行/列。
idx – 待访问的数组的索引。
val – 新值。

std::string getStrAttrIndex(std::string att, MdoI32 idx) const¶

此函数会检索字符串值行/列属性的值。

Parameters

att – 待访问的字符串值行/列属性。
idx – 待访问的数组的索引。

Return

字符串值行/列属性的值。

void setIntAttr(std::string att, MdoI32 val)¶

此函数会更改 32 位整数值模型属性的值。

Parameters

att – 待访问的整数值模型属性。
val – 新值。

MdoI32 getIntAttr(std::string att) const¶

此函数会检索 32 位整数值模型属性的值。

Parameters: att – 待访问的整数值模型属性。
Return: 32 位整数值模型属性的值。

void setIntAttrIndex(std::string att, MdoI32 idx, MdoI32 val)¶

此函数会更改 32 位整数值行/列属性的值。

Parameters

att – 待访问的整数值行/列属性。
idx – 待访问的数组的索引。
val – 新值。

MdoI32 getIntAttrIndex(std::string att, MdoI32 idx) const¶

此函数会检索 32 位整数值行/列属性的值。

Parameters

att – 待访问的整数值行/列属性。
idx – 待访问的数组的索引。

Return

32 位整数值行/列属性的值。

void setIntAttrArray(std::string att, MdoI32 bgn, MdoI32 len, const MdoI32 *val)¶

此函数会更改指定的 32 位整数值行/列属性数组的值。

Parameters

att – 待访问的整数值行/列属性。
bgn – 待访问的第一个元素的索引。
len – 待访问的元素数。
val – 指定的属性数组的新值。

std::vector<MdoI32> getIntAttrArray(std::string att, MdoI32 bgn, MdoI32 len) const¶

此函数会检索指定的 32 位整数值行/列属性数组的值。

Parameters

att – 待访问的整数值行/列属性。
bgn – 待访问的第一个元素的索引。
len – 待访问的元素数。

Return

包含指定的属性数组值的 STL 矢量。

void setIntAttrVars(std::string att, std::vector<std::reference_wrapper<MdoVar>> &vars, const MdoI32 *vals)¶

此函数会更改指定的 32 位整数值列属性数组的值。

Parameters

att – 待访问的整数值数组属性。待访问的行/列属性。
vars – 包含对待访问变量的引用的矢量对象。
vals – 指定的属性数组的新值。

std::vector<MdoI32> getIntAttrVars(std::string att, std::vector<std::reference_wrapper<MdoVar>> &vars)¶

此函数会检索指定的 32 位整数值列属性数组的值。

Parameters

att – 待访问的整数值数组属性。待访问的行/列属性。
vars – 包含对待访问变量的引用的矢量对象。

Return

包含属性的指定子数组值的 STL 矢量。

void setIntAttrConss(std::string att, std::vector<std::reference_wrapper<MdoCons>> &conss, const MdoI32 *vals)¶

此函数会更改指定的 32 位整数值行属性数组的值。

Parameters

att – 待访问的整数值数组属性。待访问的行/列属性。
conss – 包含对待访问约束的引用的矢量对象。
vals – 指定的属性数组的新值。

std::vector<MdoI32> getIntAttrConss(std::string att, std::vector<std::reference_wrapper<MdoCons>> &conss)¶

此函数会检索指定的 32 位整数值行属性数组的值。

Parameters

att – 待访问的整数值数组属性。待访问的行/列属性。
conss – 包含对待访问约束的引用的矢量对象。

Return

包含属性的指定子数组值的 STL 矢量。

void setRealAttr(std::string att, MdoReal val)¶

此函数会更改实值模型属性的值。

Parameters

att – 待访问的实值模型属性。
val – 新值。

MdoReal getRealAttr(std::string att) const¶

此函数会检索实值模型属性的值。

Parameters: att – 待访问的实值模型属性。
Return: 实值模型属性的值。

void setRealAttrIndex(std::string att, MdoI32 idx, MdoReal val)¶

此函数会更改实值行/列属性的值。

Parameters

att – 待访问的实值行/列属性。
idx – 待访问的数组的索引。
val – 新值。

MdoReal getRealAttrIndex(std::string att, MdoI32 idx) const¶

此函数会检索实值行/列属性的值。

Parameters

att – 待访问的实值行/列属性。
idx – 待访问的数组的索引。

Return

实值行/列属性的当前值。

void setRealAttrArray(std::string att, MdoI32 bgn, MdoI32 len, const MdoReal *vals)¶

此函数会更改指定的实值行/列属性数组的值。

Parameters

att – 待访问的实值行/列属性。
bgn – 待访问的第一个元素的索引。
len – 待访问的元素数。
vals – 指定的属性数组的新值。

std::vector<MdoReal> getRealAttrArray(std::string att, MdoI32 bgn, MdoI32 len) const¶

此函数会检索指定的实值行/列属性数组的值。

Parameters

att – 待访问的实值行/列属性。
bgn – 待访问的第一个元素的索引。
len – 待访问的元素数。

Return

包含指定的属性数组值的 STL 矢量。

void setRealAttrVars(std::string att, std::vector<std::reference_wrapper<MdoVar>> &vars, const MdoReal *vals)¶

此函数会更改指定的实值列属性数组的值。

Parameters

att – 待访问的实值列属性。
vars – 包含对待访问变量的引用的矢量对象。
vals – 指定的属性数组的新值。

std::vector<MdoReal> getRealAttrVars(std::string att, std::vector<std::reference_wrapper<MdoVar>> &vars)¶

此函数会检索指定的实值列属性数组的值。

Parameters

att – 待访问的实值列属性。
vars – 包含对待访问变量的引用的矢量对象。

Return

包含指定的属性数组值的 STL 矢量。

void setRealAttrConss(std::string att, std::vector<std::reference_wrapper<MdoCons>> &conss, const MdoReal *vals)¶

此函数会更改指定的实值行属性数组的值。

Parameters

att – 待访问的实值行属性。
conss – 包含对待访问约束的引用的矢量对象。
vals – 指定的属性数组的新值。

std::vector<MdoReal> getRealAttrConss(std::string att, std::vector<std::reference_wrapper<MdoCons>> &conss)¶

此函数会检索指定的实值行属性数组的值。

Parameters

att – 待访问的实值行属性。
conss – 包含对待访问约束的引用的矢量对象。

Return

包含指定的属性数组值的 STL 矢量。

访问参数设置的方法。

void setStrParam(std::string par, std::string val)¶

此函数会更改字符串值参数的值。

Parameters

par – 待访问的字符串值参数。
val – 字符串值参数的新值。

std::string getStrParam(std::string par) const¶

此函数会检索字符串值参数的值。

Parameters: par – 待访问的字符串参数。
Return: 字符串值参数的值。

void setIntParam(std::string par, MdoI32 val)¶

此函数会更改 32 位整数值参数的值。

Parameters

par – 待访问的整数值参数。
val – 32 位整数值参数的新值。

MdoI32 getIntParam(std::string par) const¶

此函数会检索 32 位整数值参数的值。

Parameters: par – 待访问的整数值参数。
Return: 32 位整数值参数的值。

void setRealParam(std::string par, MdoReal val)¶

此函数会更改实值参数的值。

Parameters

par – 待访问的实值参数。
val – 实值参数的新值。

MdoReal getRealParam(std::string par) const¶

此函数会检索实值参数的值。

Parameters: par – 待访问的实值参数。
Return: 32 位整数值参数的值。

优化模型和检索结果的方法。

void solveProb(void)¶: 此函数会为已加载的优化问题求解。

void displayResults(void) const¶

此函数会显示当前求解器的结果，包括

原始目标值和对偶目标值；
变量界限和约束违反。

MdoStatus getStatus(void) const¶

此函数会返回问题状态代码。

Return: 问题状态代码。

std::string explainStatus(MdoStatus status) const¶

此函数会说明求解器状态代码的详情。具体来讲，如果 MindOpt 成功优化已加载的问题，用户可使用此函数填入解的状态。

Parameters: status – 需说明的求解器状态代码。
Return: 包含求解器状态代码说明的字符串。

std::string explainResult(MdoResult result) const¶

此函数会说明求解器结果代码的详情。具体来讲，如果 MindOpt 未能将已加载的问题优化至最佳，用户可使用此函数来填入结果代码的详情。

Parameters: result – 需说明的求解器结果代码。
Return: 包含优化状态代码说明的字符串。

void computeIIS(void)¶: 此函数会计算至少包含一个 IIS（不可约不可行系统）的子系统。此子系统的基数应该很小。请注意，此问题应是不可行的。

内部数据访问方法。

MdoCons &getCons(MdoI32 i)¶

此函数会按索引返回对约束对象的引用。

Parameters: i – 行索引。
Return: 对约束对象的引用。

MdoCons &getCons(std::string name)¶

此函数会按名称返回对约束对象的引用。

Parameters: name – 约束名称。
Return: 对约束对象的引用

std::vector<std::reference_wrapper<MdoCons>> getConss(void)¶

此函数会返回包含对约束对象的引用的矢量。

Return: 包含对约束对象的引用的矢量。

MdoVar &getVar(MdoI32 j)¶

此函数会按索引返回对变量对象的引用。

Parameters: j – 列索引。
Return: 对变量对象的引用。

MdoVar &getVar(std::string name)¶

此函数会按给定名称返回对变量对象的引用。

Parameters: name – 变量名称。
Return: 对变量对象的引用。

std::vector<std::reference_wrapper<MdoVar>> getVars(void) const¶

此函数会返回包含对变量对象的引用的矢量。

Return: 包含对变量对象的引用的矢量。

调试程序。

inline MdoBool isDebug(void) const¶: 检查调试模式是否已打开。

inline void setDebug(MdoBool debug)¶

是否设置调试模式。

Parameters: debug – 新模式。