"Gurobi官方学习文档：优化器领域新翘楚，多语言支持、高效求解、广泛应用"

需积分: 0 121 浏览量更新于2024-01-13 收藏 2.62MB PDF 举报

Gurobi是由美国Gurobi公司开发的一种新一代大规模数学规划优化器，在Decision Tree for Optimization Software网站举行的第三方优化器评估中，展示出更快的优化速度和精度，成为优化器领域的新翘楚。数学规划优化是应用在各个领域中最常见的优化方法之一，是过去30年中在实际应用中创造价值最巨大的优化方法。在物流、生产制造、金融、交通运输、资源管理、集成电路设计、环境保护、电力管理等领域，几乎无所不在。在世界一流的企业资源管理（ERP）、供应链管理（SCM）、运输管理等企业决策工具中，都有数学规划优化器的存在。 Gurobi具有以下特点： 1) 采用最新优化技术，充分利用多核处理器的优势，能够快速高效地解决大规模数学规划问题。 2) 任何版本都支持并行计算，并且计算结果确定而非随机，保证解的准确性和稳定性。 3) Gurobi提供了方便轻巧的接口，支持C、C++、JAVA、Python、VB、MATLAB、R和VB等多种编程语言开发，而且内存消耗较小。 4) 支持多种平台，包括Windows、Linux、Mac OS X等，能够在不同操作系统下进行优化计算。 5) 支持多种建模环境，包括AMPL、GAMS、AIMMS、Tomlab和Windows Solver Foundation等，提供了灵活多样的建模方式。 Gurobi官方提供了全面的学习文档，覆盖了C、C++、JAVA、Python、VB、MATLAB、R和VB等各种语言的使用。学习文档中包含了丰富的示例和演示，帮助用户快速上手和掌握Gurobi的使用方法。在学习文档中，首先介绍了Gurobi的基本概念和基本操作，然后通过一系列例子展示了Gurobi的各种应用场景。这些例子包括从文件中加载和求解模型、建立模型、使用附加的建模元素等等。通过这些例子，用户可以深入了解如何使用Gurobi解决各种实际问题。总之，Gurobi是一款功能强大的数学规划优化器，具有高效、准确、稳定的优化性能，广泛应用于物流、生产制造、金融、交通运输、资源管理等各个领域。官方提供的学习文档和示例教程有助于用户快速上手并灵活运用Gurobi解决实际问题。无论是初学者还是有经验的优化专家，都可以通过学习和使用Gurobi来实现最优决策和优化效益最大化。

In C++, Java, and Python, you use the addVar method on the Model object (AddVar in C#). In

Java, this looks like:

GRBVar x = model . addVar (0.0 , 1.0 , 0.0 , GRB . BINARY , "x" );

The new variable’s lower bound, upper bound, objective coeﬃcient, type, and name are speciﬁed

as arguments. In C++ and Python, you can omit these arguments and use default values; see the

Gurobi Reference Manual for details.

The next step is to add constraints to the model. Linear constraints are added through the

GRBaddconstr function in C:

error = GR Badd c onst r ( model , 3, ind , val , GRB_L ESS _EQUAL , 4.0 , " c0 " );

To add a linear constraint in C, you must specify a list of variable indices and coeﬃcients for the

left-hand side, a sense for the constraint (e.g., GRB_LESS_EQUAL), and a right-hand side constant.

You can also give the constraint a name; if you omit the name, Gurobi will assign a default name

for the constraint.

In C++, C#, Java, and Python, you build a linear constraint by ﬁrst building linear expressions

for the left- and right-hand sides. In Java, which doesn’t support operator overloading, you build

an expression as follows:

// Set obj ect ive : ma ximize x + y + 2 z

GR BLin Expr expr = new GRBL inEx pr ();

expr . addTe rm (1.0 , x ); expr . addTerm (1.0 , y ); expr . a ddTerm (2.0 , z);

You then use the addConstr method on the GRBModel object to add a constraint using these linear

expressions for the left- and right-hand sides:

model . add Con str ( expr , GRB . LESS_EQUAL , 4.0 , " c0 " );

For C++, C#, and Python, the standard mathematical operators such as +, *, <= have been

overloaded so that the linear expression resembles a traditional mathematical expression. In C++:

model . Add Con str (x + 2 * y + 3 * z <= 4.0 , " c0 " );

Once the model has been built, the typical next step is to optimize it (using GRBoptimize in

C, model.optimize in C++, Java, and Python, or model.Optimize in C#). You can then query

the X attribute on the variables to retrieve the solution (and the VarName attribute to retrieve the

variable name for each variable). In C, the X attribute is retrieved as follows:

error = GR B g etdbla t t rarray ( model , GR B_D BL_ATTR_ X , 0, 3, sol );

In C++:

cout << x. get ( GRB_Str i n g Attr_Va r N a me ) << " "

<< x. get ( GRB_D o u bleAt t r_X ) << endl ;

cout << y. get ( GRB_Str i n g Attr_Va r N a me ) << " "

<< y. get ( GRB_D o u bleAt t r_X ) << endl ;

cout << z. get ( GRB_Str i n g Attr_Va r N a me ) << " "

<< z. get ( GRB_D o u bleAt t r_X ) << endl ;

In Java:

System . out . pr int ln (x. get ( GRB . Stri ngAt tr . Var Nam e )

+ " " +x. get ( GRB . Dou bleA ttr .X ));

System . out . pr int ln (y. get ( GRB . Stri ngAt tr . Var Nam e )

+ " " +y. get ( GRB . Dou bleA ttr .X ));

System . out . pr int ln (z. get ( GRB . Stri ngAt tr . Var Nam e )

+ " " +z. get ( GRB . Dou bleA ttr .X ));

In C#:

Console . Wri teLine ( x . Var Nam e + " " + x.X );

Console . Wri teLine ( y . Var Nam e + " " + y.X );

Console . Wri teLine ( z . Var Nam e + " " + z.X );

In Python:

for v in m. g etV ars ():

print ( ’%s %g ’ % (v. VarName , v . X ))

When querying or modifying attribute values for an array of constraints or variables, it is

generally more eﬃcient to perform the action on the whole array at once. This is quite natural

in the C interface, where most of the attribute routines take array arguments. In the C++, C#,

Java, and Python interfaces, you can use the get and set methods on the GRBModel object to

work directly with arrays of attribute values (getAttr/setAttr in Python). In the sudoku Java

example, this is done as follows:

double [] [][] x = model . get ( GRB . Do uble Attr .X , vars );

We should point out one important subtlety in our interface. We use a lazy update approach to

building and modifying a model. When you make changes, they are added to a queue. The queue

is only ﬂushed when you optimize the model (or write it to a ﬁle). In the uncommon situation

where you want to query information about your model before optimizing it, you should call the

update method before making your query.

2.4 Additional modeling elements

Examples: bilinear, gc_pwl, gc_pwl_func, genconstr, multiobj, multiscenario, piecewise, qcp, qp,

sensitivity, sos

A mathematical programming model in its traditional form consists of a linear objective, a

set of linear constraints, and a set of continuous or integer decision variables. Gurobi supports a

number of additional modeling constructs. In addition to linear constraints, Gurobi also supports

SOS constraints, quadratic constraints, and general constraints. In addition to a single linear

objective, Gurobi also supports quadratic objectives, piecewise-linear objectives, and multiple linear

objectives. Consult the corresponding examples from the Gurobi distribution for simple examples

of how to use each of these modeling elements.

2.5 Modify a model

Examples: diet, feasopt, ﬁxanddive, gc_pwl_func, lpmod, sensitivity, workforce3, workforce4,

workforce5

This section considers model modiﬁcation. Modiﬁcation can take many forms, including adding

constraints or variables, deleting constraints or variables, modifying constraint and variable at-

tributes, changing constraint coeﬃcients, etc. The Gurobi examples don’t cover all possible modi-

ﬁcations, but they cover the most common types.

diet

This example builds a linear model that solves the classic diet problem: to ﬁnd the minimum cost

diet that satisﬁes a set of daily nutritional requirements. Once the model has been formulated and

The model is re-solved simply by calling the optimize method again. For a continuous model, this

starts the optimization from the previous solution. To illustrate the diﬀerence when solving the

model from an initial, unsolved state, the lpmod example calls the reset function. In C:

error = GRBr ese t ( model , 0);

In C++, Java, and Python:

model . reset ();

In C#:

model . Reset ();

When we call the optimize method after resetting the model, optimization starts from scratch.

Although the diﬀerence in computation time is insigniﬁcant for this tiny example, a warm start

can make a big diﬀerence for larger models.

ﬁxanddive

The fixanddive example provides another example of bound modiﬁcation. In this case, we re-

peatedly modify a set of variable bounds, utilizing warm starts each time. In C, variables are ﬁxed

as follows:

for (j = 0; j < nfix ; ++ j)

{

fixval = floor ( fra ctio nal [j ]. X + 0.5);

error = GR B s e tdblat t r e lement ( model , " LB " , fra ctio nal [j ]. index , fixv al );

if ( error ) goto QUIT ;

error = GR B s e tdblat t r e lement ( model , " UB " , fra ctio nal [j ]. index , fixv al );

if ( error ) goto QUIT ;

error = GR B g e tstrat t r e lement ( model , " Var Name " ,

fr acti onal [j ]. index , & vname );

if ( error ) goto QUIT ;

printf (" Fix %s to %f ( rel %f )\ n" , vname , fixval , fr acti onal [j ]. X );

}

In C++:

for ( int i = 0; i < nfix ; ++ i)

{

GRBVar * v = fr acti onal [i ];

double fixval = floor (v - > get ( G R B _Doub l e Attr_ X ) + 0.5);

v - > set ( G RB_Doub leA ttr_LB , f ixval );

v - > set ( G RB_Doub leA ttr_UB , f ixval );

cout << " Fix " << v -> get ( G R B_Strin g A t tr_VarN a m e ) << " to " <<

fixval << " ( rel " << v - > get ( G R B _Doub l eAttr_ X ) << " )" <<

endl ;

}

In Java:

for ( int i = 0; i < nfix ; ++ i) {

GRBVar v = fract iona l . get ( i );

double fixval = Math . floor ( v . get ( GRB . D oubl eAtt r . X ) + 0.5);

v. set ( GRB . Dou bleA ttr .LB , fi xval );

v. set ( GRB . Dou bleA ttr .UB , fi xval );

System . out . pr int ln (" Fix " + v. get ( GRB . Str ingA ttr . VarName ) +

" to " + f ixval + " ( rel " + v. get ( GRB . Dou bleA ttr .X ) + " )" );

}

剩余633页未读，继续阅读

Uoyaij_

粉丝: 44
资源: 5

"Gurobi官方学习文档：优化器领域新翘楚，多语言支持、高效求解、广泛应用"

gurobi学习文档（中英文）

gurobi学习手册，很好用的自定义机器学习数学建模编程语言

Gurobi方法文档.pdf

gurobi python

python gurobi

python Gurobi

gurobi matlab

Gurobi matlab

gurobi c++

matlab GUROBI

最新资源