Optimization Solver:User Manual of Optimization Solver

Examples of calling Optimization Solver by using CLI

Assume that you have installed Optimization Solver in the directory specified by the environment variable $MINDOPT_HOME according to the installation document. In Linux or macOS, run the following command to call Optimization Solver:

mindopt $MINDOPT_HOME/examples/data/afiro.mps

In Windows, run the following command to call Optimization Solver:

mindopt %MINDOPT_HOME%\examples\data\afiro.mps

Examples of calling Optimization Solver in Python, Java, C++, C#, C and MATLAB languages

env = mindoptpy.Env()
env.start()
model = mindoptpy.read(filename, env)
model.optimize()
print(f"Optimal objective value is: {model.objval}")
for v in x:
    print(f"{v.VarName} = {v.X}")

MDOEnv env = new MDOEnv();
MDOModel model = new MDOModel(env, filename);
model.optimize();
System.out.println("Optimal objective value is: " + model.get(MDO.DoubleAttr.ObjVal));
MDOVar[] x = model.getVars();
for (int i = 0; i < x.length; ++i) {
    System.out.println(x[i].get(MDO.StringAttr.VarName) + " = " + x[i].get(MDO.DoubleAttr.X));
}

MDOEnv env = MDOEnv();
MDOModel model = MDOModel(env, filename);
model.optimize();
std::cout << "Optimal objective value is: " << model.get(MDO_DoubleAttr_ObjVal) << std::ends;
std::vector<MDOVar> vars = model.getVars();
for (auto v : vars) {
    std::cout << v.get(MDO_StringAttr_VarName) << " = " << v.get(MDO_DoubleAttr_X) << std::endl;
}

MDOenv* env;
MDOemptyenv(&env);
MDOstartenv(env);
MDOmodel* model;
double obj;

MDOreadmodel(env, argv[1], filename);
MDOoptimize(model);
MDOgetdblattr(model, MDO_DBL_ATTR_OBJ_VAL, &obj);
printf("Optimal objective value is: %f\n", obj);

/* Free the environment. */
MDOfreemodel(model);
MDOfreeenv(env);

MDOEnv env = new MDOEnv();
MDOModel model =new MDOModel(env, filename);
model.optimize();
Console.WriteLine($"Optimal objective value is: {model.Get(MDO.DoubleAttr.ObjVal)}");
MDOVar[] vars = model.GetVars();
for (int i = 0; i < vars.Length; i++)
{
    Console.WriteLine($"{vars[i].Get(MDO.StringAttr.VarName)} = {vars[i].Get(MDO.DoubleAttr.X)}");
}

model = mindopt_read(file);
result = mindopt(model);

for v=1:length(result.X)
    fprintf('%s %d\n', model.varnames{v}, result.X(v));
end
fprintf('Optimal objective value is: %e\n', result.ObjVal);

objval = result.ObjVal;

For information about the complete sample code, see Call methods.

Method 1: Input problems by using files

• Optimization Solver supports MPS and LP files, including files with the extensions .mps and .lp, as well as their compressed files such as .mps.gz and .mps.bz2 files.

• .dat-s files. For example, you can input SDP problems by using .dat-s files.

• .qps format. For example, QP problems.

• The mindoptampl module supports .nl files. For example, you can enter mindoptampl filename.nl on CLI.

For more information, see Input file format: mps/lp/dat-s.

Method 2: Input problems by calling API operations

You can input a problem by calling multiple API operations.

• Example of inputting a problem by row in Python

  • Call mindoptpy.Model.modelsense = MDO.MINIMIZE to set the target obj function to Minimization.

  • Call mindoptpy.Model.addVar() to add four optimization variables and define the upper bound, lower bound, objective coefficient, name, and type of the variables.

  • Call mindoptpy.Model.addConstrs() to add constraints.

• Example of inputting a problem by column in Python

  • Call mindoptpy.Model.modelsense = MDO.MAXIMIZE to set the target obj function to Minimization.

  • Call mindoptpy.Model.addConstrs() to create a constraint with the specified left-hand and right-hand values (no non-zero elements).

  • Call mindoptpy.Model.Column() to create a temporary column object for holding the values of the constraint and non-zero elements in order.

  • Call mindoptpy.Model.addVar() to create a variable, including the corresponding objective function coefficient, non-zero elements in the column vector, the lower and upper bounds of the variable, the variable name, and the variable type.

For more information about how to build models and solve problems, see Modeling and Optimization. For information about attributes, see Attributes. And more examples.

Method 3: Input problems by using modeling tools such as AMPL, Pyomo, PuLP, and MindOpt APL

This section describes the modeling tools that are supported by Optimization Solver.

1. MindOpt APL

MindOpt Algebraic Programming Language (MindOpt APL or MAPL) is an efficient algebraic modeling language for optimization. It supports a variety of solvers.

• You can try out MindOpt APL for free on the MindOpt Studio, a cloud-based platform for modeling and solving optimization problems, in a browser. You can also learn the cases to quickly get started with MindOpt APL. You can use MindOpt APL in a browser without the need for installing any software.

• Syntax tutorial: doc.

2. AMPL

Before you use AMPL to call Optimization Solver, make sure that you have installed Optimization Solver and AMPL. The mindoptampl module is stored in \bin\mindoptampl of the installation package. The mindoptampl module provides some configurable parameters. You can use the AMPL option command to set the mindoptampl_options parameter. For example:

ampl: option mindoptampl_options 'numthreads=4 maxtime=1e+4';

For more information, see AMPL.

3. Pyomo

Before you use Pyomo to call Optimization Solver, make sure that you have installed Optimization Solver and Pyomo. The mindopt_pyomo.py file is required when the Pyomo API is used to call Optimization Solver. The Pyomo API is inherited from the DirectSolver class of Pyomo and its implementation code is included in \lib\pyomo\mindopt_pyomo.py of the installation package. You need to run the following command to import the mindopt_pyomo.py file to Python code:

from mindopt_pyomo import MindoDirect

For more information, see Pyomo.

4. PuLP

Before you use PuLP to call Optimization Solver, make sure that you have installed Optimization Solver and PuLP. The mindopt_pulp.py file is required when the PuLP API is used to call Optimization Solver. The PuLP API is inherited from the LpSolver class of PuLP and its implementation code is included in \lib\pulp\mindopt_pulp.py of the installation package. You need to run the following command to import the mindopt_pulp.py file to Python code:

from mindopt_pulp import MINDOPT

For more information, see PuLP.

5. JuMP

JuMP is an open-source modeling tool based on the Julia programming language. Before you use PuLP to call Optimization Solver, make sure that you have installed MindOpt, Julia, JuMP and AmplNLWriter. Next, we need to call the JuMP API to create a model object, specifying mindoptampl as the solver.

model = Model(() -> AmplNLWriter.Optimizer(mindoptampl))

For more information, see JuMP.

Computing device configuration reference (use different algorithms for solving LP problems)

The device resources consumed vary based on the problem structure and algorithm selected. You need to select an algorithm based on your business requirements.

Optimization Solver can solve LP problems by using the simplex method, IPM, and concurrent optimization method. When Optimization Solver solves a problem according to the process illustrated in the following section, the concurrent optimization method is selected by default. You can set the "Method" parameter to a specific algorithm.

The following table describes the differences between the three algorithms.

Requirements for the computing device

The requirements for the computing device may vary based on the types of problems. You need to configure the computing device based on your business requirements. The following lab test values are used for reference only.

By using CLI

If you solve a problem by using CLI, summaries of the solving process and the solution are displayed, and .bas and .sol solution documents with the same name as the solved file are generated next to the solved file.

In the following example, the afiro.bas and afiro.sol files are generated after the mindopt afiro.mps file is executed. The .bas file holds the basis, and the .sol file holds the optimal objective value and variable values.

By calling API operations

After you input a problem, you can call optimize() to solve the problem. For example, in Python, you can call model.optimize() to resolve the problem.

After the problem is solved, you can call relevant API operations to obtain the solving results. For example, in Python:

• You can call model.status to obtain the solving status.

• You can call model.objval to obtain the primal objective value.

  • You can also call model.getAttr(MDO.Attr.PrimalObjVal) to obtain the primal objective value. Similarly:

    • UseSolutionTime to obtain the total execution time in seconds.

    • Use DualObjVal to obtain the dual objective value.

    • Use ColBasis to obtain the basis of the primal solution.

• You can call var.X to obtain the value of decision variables.

• For more information about solution attributes, see Attributes.

For information about the complete sample code, see the example folder in the installation package, or see Modeling and optimization or examples.

Constraint infeasibility analysis

When you build a model to solve an optimization problem, the problem may be infeasible because certain constraints conflict with each other. Analyzing the infeasible problem and identifying the key conflicting constraints can help build models. The minimum subset of the constraints that make the problem infeasible is called an irreducible infeasible system (IIS).

Optimization Solver provides API operations for computing IISs. You can call an operation to analyze an infeasible problem, and modify or remove the constraints in the IIS based on the analysis results to make the problem feasible.

The following example shows how to call an API operation to compute an IIS in Python:

if model.status == MDO.INFEASIBLE or model.status == MDO.INF_OR_UBD:
    idx_rows, idx_cols = model.compute_iis()

For more information about how to compute IISs, see Analysis of constraint conflicts.

Callback

MindOpt adopts the classical branch and bound method to solve MIP problems. MindOpt provides users with callback functions to track and modify the optimization process of MIP problems. Users can use callbacks to modify the behavior of the MIP optimizer, including:

• Add cutting planes to cut off branches that will not lead to the optimal solutions.

• Modify the branch selection strategy of MindOpt to control node branching methods and traversal order.

• Add feasible solutions (e.g., solutions obtained through self-implemented heuristic algorithms). A good feasible solution can improve the solving efficiency of MindOpt.

def callback(model, where):

For more information, see Callback.

MindOpt Tuner

MindOpt Tuner is a hyperparameter tuning tool. It supports automatic tuning of various open-source/commercial solvers such as MindOpt optimization solver to maximize the solver's performance on a specific problem or set of problems, including reducing solving time and optimizing the gap of the solution. Meanwhile, MindOpt Tuner can be used in conjunction with MindOpt APL modeling language, supporting parameter tuning for all the integrated solvers.

You can try it free on link.

MindOpt Copilot help you modeling and coding

MindOpt Copilot is an advanced AI solution developed from large language models, designed to assist users with "mathematical programming" problems using MindOpt technology. Tailored for both beginners and experts, it offers insightful consulting, problem modeling, and coding in the realm of mathematical programming. The platform seamlessly integrates with tools like MindOpt Solver and MindOpt APL. Additionally, with its ability to interpret natural languages and tabular data (.csv files), MindOpt Copilot can autonomously carry out mathematical modeling, generate formulas, draft code to solve specific business issues.

You can try it free on link.

Solving process of Optimization Solver

The following example demonstrates how an LP problem is solved. When you solve optimization problems of other types, the specific algorithms will be automatically adapted.