The Gurobi Optimizer is a state-of-the-art solver
for linear programming (LP), quadratic programming
(QP) and mixed-integer programming (MILP and MIQP).
It was designed from the ground up to exploit modern
multi-core processors. Every Gurobi license allows
parallel processing, and the Gurobi Parallel
Optimizer is deterministic: two separate runs on the
same model will produce identical solution paths.
For solving LP and QP models, the Gurobi Optimizer
includes high-performance implementations of the
primal simplex method, the dual simplex method, and
a parallel barrier solver. For MILP and MIQP models,
the Gurobi Optimizer incorporates the latest methods
including cutting planes and powerful solution
heuristics. All models benefit from advanced
presolve methods to simplify models and slash solve
times.
The Gurobi Optimizer is written in C and is
accessible from several languages. In addition to a
powerful, interactive Python interface and a
matrix-oriented C interface, we provide
object-oriented interfaces from C++, Java, Python,
and the .NET languages. These interfaces have all
been designed to be lightweight and easy to use,
with the goal of greatly enhancing the accessibility
of our products. And since the interfaces are
lightweight, they are faster and use less memory
than other standard interfaces. Our online
documentation (Quick Start Guide, Example Tour and
Reference Manual) describes the use of these
interfaces.
Gurobi is also available through several powerful
third-party modeling systems including AIMMS, AMPL,
FRONTLINE SOLVERS, GAMS, MPL, OptimJ and TOMLAB.
Version 4.0 of the Gurobi Optimizer includes a
number of enhancements. Users of previous versions
may need to make a few minor changes to their
existing programs. Here are the new features, and
the likely changes required to existing programs.
New features:
* Quadratic programming: The Gurobi Optimizer now
supports models with quadratic objective
functions. The new version includes primal
simplex, dual simplex, and parallel barrier
optimizers for continuous QP models, and a
parallel branch-and-cut solver for Mixed Integer
Quadratic Programming (MIQP) models.
* Concurrent optimizer: The Gurobi Optimizer now
allows you to run multiple algorithms
simultaneously when solving a linear continuous
model on a multi-core machine. The optimizer
returns when the first algorithm solves the model.
We include both a standard concurrent optimizer
and a deterministic concurrent optimizer. The
latter returns the exact same solution every time
you run it, while the former can sometimes return
different optimal solutions from one run to the
next. The former can sometimes be significantly
faster.
* MIP performance: The MIP solver is faster in
release 4.0. These improvements do not require any
parameter changes.
* LP performance: The simplex and barrier solvers
are slightly faster in release 4.0. We have also
improved the numerical stability of the primal
simplex solver and the barrier crossover
algorithm.
* Delayed MIP strategy change: The Gurobi Optimizer
now gives you the option to change a few MIP
parameters in the middle of the optimization in
order to dynamically shift the search strategy.
Specifically, two new parameters, ImproveStartGap
and ImproveStartTime, allow you to specify when
the algorithm should modify the values of a few
parameters that control the intensity of the MIP
heuristics. By setting one or both of these
parameters to non-default values, you can cause
the MIP solver to switch from its standard
parameter settings, where it tries to strike a
balance between finding better solutions and
proving that the current solution is optimal, to a
set of parameter values that focus almost entirely
on finding better solutions.
* Support for Visual Studio 2010: Gurobi Optimizer
now supports Microsoft Visual Studio 2010. This
change only affects C++ users, who will find new
libraries gurobi_c++2010md.lib,
gurobi_c++2010mdd.lib, gurobi_c++2010mt.lib, and
gurobi_c++2010mtd.lib in the lib directory of the
Gurobi distribution.
* Explicit license release in Java and .NET: The new
version includes an explicit method for releasing
a Gurobi license. You no longer need to rely on
the garbage collector to reclaim unused licenses.
* New methods, attributes, parameters, and error
codes: To support the new features in Gurobi 4.0,
we have added several new methods, attributes,
parameters, and error codes. You can learn more
about these in the {Gurobi Reference Manual}.
New methods:
* New C methods for managing Q: the C interface
includes three new routines, GRBaddqpterms,
GRBdelq, and GRBgetq. These allow you to add,
delete, and retrieve quadratic objective terms,
respectively.
* Quadratic expressions: the object oriented
interfaces include a new quadratic expression
class, GRBQuadExpr, which can be used to build
quadratic objective functions.
* getObjective/setObjective: the object oriented
interfaces include new GRBModel methods that allow
you to retrieve the current objective function as
a linear or quadratic expression, and allow you to
set the objective equal to a linear or quadratic
expression.
* getValue: the object oriented interfaces include a
new getValue method that allows you to compute the
value of a GRBLinExpr or GRBQuadExpr object for
the current solution.
* License release: the Java and .NET interfaces
include a new release method that allows you to
release the license held by an environment
immediately, instead of having to wait for the
garbage collector to reclaim the GRBEnv object.
New attributes:
* IsQP: model attribute that indicates whether the
model has any quadratic terms.
* NumQNZs: model attribute that returns the number
of quadratic terms in the objective function.
New parameters:
* Method: the previous LPMethod parameter has been
renamed to Method. This new parameter controls the
algorithm used to solve continuous linear and
quadratic models. We have added two new options:
concurrent and deterministic concurrent. This
parameter also selects the algorithm used to solve
the root node of a MIP model.
* NodeMethod: chooses the algorithm used to solve
node relaxations in a MIP model.
* ModKCuts: controls the generation of mod-k cuts.
* ImproveStartGap: allows you to specify the
optimality gap at which the MIP solver resets a
few MIP heuristics parameters in order to shift
the attention of the MIP solver to finding the
best possible feasible solution.
* ImproveStartTime: allows you to specify the
elapsed time at which the MIP solver resets a few
MIP heuristics parameters in order to shift the
attention of the MIP solver to finding the best
possible feasible solution.
* PreMIQPMethod: chooses the presolve transformation
performed on MIQP models.
* PSDTol: sets a limit on the amount of diagonal
perturbation that the optimizer is allowed to do
on the Q matrix for a quadratic model. If a larger
perturbation is required, the optimizer will
terminate with an GRB_ERROR_Q_NOT_PSD error.
New error codes:
* GRB_ERROR_Q_NOT_PSD: This new error code is
returned when you attempt to solve a QP model
where the Q matrix is not positive semi-definite
(meaning there exists an x for which x\’Qx ). Note
that the optimizer will always
Product:Gurob Optimization Gurobi v4.0
Lanaguage:english
Platform:Winxp/Win7
Size:9.1 MB