Enhancement Summary for 9.1
Gurobi 9.1 delivers significant speed improvements and new features – gives customers across numerous industries (including financial services, oil & gas, and chemicals) the capability to use mathematical optimization to generate high-quality solutions to a broader array of business problems than ever before.
With Gurobi 9.1, the Gurobi Optimizer – which was tested using Gurobi’s test library comprised of thousands of real-world models – registered notable performance improvements across multiple problem types including:
- Primal simplex: 17% faster overall, 37% faster on models that take at least 100 seconds.
- Dual simplex: 29% faster overall, 66% faster on models that take at least 100 seconds.
- Barrier: 15% faster overall, 34% faster on models that take at least 100 seconds.
- Mixed-integer linear programming (MILP): 5% faster overall, 9% faster on models that take at least 100 seconds.
- Convex mixed-integer quadratic programming (MIQP): 5% faster overall, 20% faster on models that take at least 100 seconds.
- Convex mixed-integer quadratically constrained programming (MIQCP): 13% faster overall, 57% faster on models that take at least 100 seconds.
- Non-convex mixed-integer quadratically constrained programming (non-convex MIQCP): 4x faster overall, 9x faster on models that take at least 100 seconds.
- Irreducible Infeasible Subset (IIS) computation: 2.6x faster overall, 5.7x faster on models that take at least 100 seconds.
- Better MIP feasible solutions: Heuristics are significantly better at finding high-quality solutions earlier.
We are happy to help you benchmark your models with Gurobi Version 9.1. Please submit a Gurobi Support ticket to get started.
The new features in the release include:
- NoRel Heuristic: This new heuristic finds high-quality solutions in situations where the linear programming (LP) relaxation of the mixed-integer programming (MIP) problem is too expensive to solve.
- Integrality Focus: This new feature allows users to be much stricter on integrality constraints, thus avoiding many undesirable results (including trickle flows) that can come from small integrality violations.
- Python Matrix API Enhancements: Gurobi’s Python interface – gurobipy – has been extended and improved to better support matrix-oriented modeling.
- Pip Install Support: Users can now utilize pip, a Python tool, to install Gurobi in their Python environment.
- Releasing the GIL in Python API: When the optimize() method is called, gurobipy now releases the Global Interpreter Lock (GIL), which allows user programs to execute Python code in another Python thread while optimize() is running.
- Tuning Tool Enhancements: We added a number of additional controls to our tuning tool.
- Record/Replay for Compute Server and Cloud: We now support the record/replay feature for Gurobi Compute Server and Gurobi Instant Cloud.
- Pre-specified User Cuts: By setting the Lazy linear constraint attribute to the new value -1, the user can declare a linear constraint to be a user cut. The constraint must be redundant with respect to the rest of the model. The solver can optionally add user cuts to the relaxation in order to cut off LP solutions that are encountered during the MIP solving process and potentially improve performance.
Enhancement Summary for 9.0
Breakthrough New Capability
Find globally optimal solutions to classic bilinear pooling and blending problems.
- Non-Convex Quadratic Optimization – We added a new bilinear solver that allows you to solve problems with non-convex quadratic constraints and objectives.
Our maniacal focus on speed continues.
Gurobi Version 9.0 delivers significant performance improvements across LP, MIP, and MIQP problem types compared to v8.1.
- LP – In default settings is 7% faster.
- Barrier – 7% faster and an additional 4% faster with computers supporting AVX 512.
- MIP – 18% faster overall and 26% faster on difficult models that take more than 100 seconds to solve.
- MIQP – 24% faster.
New functionality in the Optimizer simplifies your workflow.
- Python Matrix API – We have extended our Python interface to support matrix-oriented modeling using NumPy or SciPy matrices.
- Piecewise-Linear (PWL) Constraints – You can now add PWL constraints directly as a modeling construct instead of having to represent them as a combination of linear and SOS constraints.
- Function Constraints With Automatic PWL Translation – This release allows you to add nine basic, nonlinear, univariate function constraints, including polynomial, exponential, logarithmic, and trigonometric functions. We will perform an automatic piecewise-linear approximation of these functions.
- MIP Scenario Analysis – This new feature allows you to describe multiple sets of changes to a model (scenarios) and computes the impact of these changes on the solution.
- New Solution Improvement Heuristic – New, much more effective heuristic for focusing on improving MIP solutions.
- Intermediate Solution Files – We now allow you to write solutions found during the MIP solution process to files as soon as they are discovered.
Gurobi Compute Server
New functionality for on-premises and private cloud deployment.
- New Non-Interactive Solve (Batch Mode) and APls – With the Cluster Manager, clients can now submit a non-interactive optimization task. A client can build an optimization model locally, submit it, and then disconnect from the server. Once the batch is completed, the client can retrieve the results.
- New Web User Interface – With the Cluster Manager, users can now easily monitor and administrate user accounts, cluster nodes, jobs, and batches. Users can also submit batches from files using a drag-and-drop interface.
- New Job/Batch History – With the Cluster Manager, users can now keep persistent records of submitted jobs and batches, so you can monitor the cluster usage by user, application, or time range.
- Support for Lazy Constraints Callbacks – Now, applications that need to add lazy constraints on the fly from within the callback can also run on the Compute Server or the Cluster Manager.
- New Cluster Manager – The Cluster Manager is a new server component that can be installed with your Compute Server nodes. It provides better security with user authentication and API keys. It also expands the capabilities of the cluster nodes with a unified management of interactive and non-interactive optimization tasks.
Enhancement Summary for 8.1
Gurobi Optimizer v8.1 continues to push the envelope of solver speed and performance. The overall v8.1 performance improvements versus v8.0 include:
- MIQP is more than a factor of 2.8x faster overall, and more than a factor of 6x faster on difficult models that take more than 100 seconds to solve.
- MIQCP is 38% faster overall, and 92% faster on difficult models that take more than 100 seconds to solve.
- LP in default settings is 2.9% faster overall, and 6.5% faster on difficult models that take more than 100 seconds to solve.
- LP barrier is 4.4% faster overall, and 11% faster on difficult models that take more than 100 seconds to solve.
- LP dual simplex is 4.2% faster overall, and 10.5% faster on difficult models that take more than 100 seconds to solve.
- Gurobi Instant Cloud now supports Microsoft Azure®: Instant Cloud users can now use Microsoft Azure, in several regions.
- Gurobi Instant Cloud adds faster and more powerful machines on Amazon EC2®: The new version supports c5, r5 and z1 instance types.
- New Q matrix linearization for MIQP and MIQCP models: We added a new Q matrix linearization approach in presolve. This new option can be chosen by setting parameter PreQLinearize to the new value of 2.
- Improved Mac Installation Package: Users no longer need to install Xcode to perform the installation.
- Support for Python 3.7: We have added support for Python 3.7 on Windows, Linux and Mac platforms.
- A callback function for multi-objective optimization: We now let users terminate optimization for individual objectives for multi-objective MIP models.
With Version 8.1, Gurobi continues to show its commitment to providing the best solvers, features and support to help you succeed with optimization.
Enhancement Summary for 8.0
Video: What’s New in Gurobi 8.0
Gurobi Optimizer v8.0 continues to push the envelope of solver speed and performance. The overall v8.0 performance improvements versus v7.5 include:
- MIP is 16% faster overall and 26% faster on difficult models that take more than 100 seconds to solve.
- LP – Dual Simplex is 12% faster overall, a very notable improvement for this class of models.
- We are happy to help you benchmark your models with Gurobi v8.0. Please submit a case on the Gurobi Support Portal.
- Enhanced R and MATLAB APIs – The R and MATLAB APIs have been significantly improved to provide nearly all the capabilities of other Gurobi APIs. The improved interfaces now support multi-objective optimization, general constraints, etc.
- Support for .NET Core 2.0 – Support for .NET Core on Windows, Linux and Mac platforms has been added. This allows .NET programs to run on more than just Windows systems.
- Multiple MIP Starts – Support for multiple MIP starts.
- Partition Heuristic – A new MIP heuristic that performs local search within user-specified partitions.
- Callbacks for Multi-Objective Optimization – User callbacks are now supported.
New Compute Server Capabilities
Gurobi Compute Server is now packaged and installed as a separate component and includes a number of new features:
- Standard Communication Protocol – Support for HTTP and HTTPS has been added for improved security, ease of deployment, and robustness.
- Clustering – New clustering that allows nodes to be added to and removed from clusters dynamically.
- Commands – A new command line tool can now monitor and manage your cluster. Users can display the status of the cluster, list running and recently processed jobs, and access job logs and parameters. An administrator can list the licenses, abort jobs, and manage the nodes of the cluster.
- REST API – A new cluster REST API allows you to programmatically monitor and manage your cluster.
New Instant Cloud Capabilities
Gurobi Instant Cloud has been enhanced with the following new features:
- HTTPS – Support for HTTPS has been added for better security, robustness, and easier integration.
- Job List – A new job list now displays the jobs queued, running, and recently processed.
- Job Dashboard – A new dashboard displays detailed job information, such as job status, log files, parameters, and metrics, in one place.
- Job History – A new archive functionality allows users to store job logs and statuses from the past three months.
- Pool Scaling – New pool scaling allows the user to dynamically add or remove machines to and from pools.
- Machine Metrics – New machine metrics display CPU and memory usage on each machine.
- REST API – Extended REST API has been added to access job information and control pool scaling.
Enhancement Summary for 7.5
The Gurobi Optimizer v7.5 extends our tradition of providing significant performance enhancements with each new release. The overall performance improvements from v7.0 on models that take more than one second to solve include:
- 32% faster (70% faster on models that take >100 seconds to solve)
- Concurrent: 15% faster (47% faster on models that take >100 seconds to solve)
- Dual Simplex: 19% faster (42% faster on models that take >100 seconds to solve)
- Barrier: 9% faster (34% faster on models that take >100 seconds to solve)
- 220% faster (too few models >100s to compare)
- 17% faster (too few models >100s to compare)
A number of MIQCP and QP models also saw improved results in v7.5. However, overall results on our MIQCP test set were down 8% and overall QP results were down 2%. While we’re seeing improvements on the vast majority of models in our test sets, results on your models may vary. We are happy to help you benchmark your models with Gurobi v7.5. Please submit a case on the Gurobi Support Portal.
Python Modeling Enhancements
Our Python modeling interface has been extended to further simplify the task of translating mathematical models into efficient implementations. This version contains new, simplified syntax for specifying general constraints (min, max, abs, and, or, and indicator), and for range constraints. For more information, see the Python API Overview section in the Reference Manual.
Simplified multi-objective interface
Our multi-objective interface has been greatly simplified. You can now specify objectives through a single setObjectiveN routine. For an overview see the Multiple Objectives section in the Reference Manual.
Enhanced multi-objective control
Our new multi-objective environments feature allows you to set termination parameters for each pass of the multi-objective optimization algorithm separately. For an overview see the Multiple Objectives section in the Reference Manual.
Fewer constraint violations in MIQP solutions
We have tightened our internal tolerances for MIQP models to reduce the number of cases where the solution exhibits small constraint violations.
Our Java interface now includes a JavaDoc version of our documentation.
Support for Python 3.6 and R 3.4
We’ve added support for Python 3.6 (including Anaconda 3.6) on Linux, Mac, and Windows, as well as support for R 3.4.
Support for Visual Studio 2017
We’ve added support for Visual Studio 2017 on Windows.
With the release of 7.5, we’ve added support for two additional parameters:
- IgnoreNames: Ignores user-provided variable and constraint names.
- StartNodeLimit: Provides additional control over how much work is performed to complete a partial MIP start.
Enhancement Summary for 7.0
The Gurobi Optimizer 7.0 extends our tradition of providing significant performance enhancements with each new release. The overall performance improvements from v6.5 on models that take more than one second to solve include:
- MIP: 22% faster (38% faster on models that take >100 seconds to solve)
- LP (concurrent): 10% faster (25% faster on models that take >100 seconds to solve)
- QCP: 46% faster (66% faster on models that take >100 seconds to solve)
- MIQCP: 48% faster (164% faster on models that take >100 seconds to solve)
- MIQP: 9% (18% faster on models that take >100 seconds to solve)
Python Modeling Enhancements
Our Python modeling interface has been greatly enhanced. We provide new methods and classes that further simplify the task of translating mathematical models into efficient implementations.
Support for Multiple Objectives
You can now associate multiple, independent optimization objectives with your model, and then perform either blended or lexicographic optimization on the resulting multi-objective model.
MIP Solution Pool Support
You can now obtain more than just one optimal solution to your MIP model. Specifically, you can now request the N best solutions, or N solutions that are less than a specified gap from the optimal solution.
New General Constraints
You can now enter several commonly occurring types of constraints without having to translate them into linear constraints yourself. Specifically, you can now add the following constraint types:
- MIN/MAX constraint: sets a decision variable equal to the min/max over a set of other decision variables
- ABS constraint: sets a decision variable equal to the absolute value of some other decision variable
- AND/OR constraint: sets a binary decision variable equal to the logical and/or over a set of other binary decision variables
- Indicator constraint: forces a linear constraint to be satisfied whenever a binary decision variable takes the specified value
Support for Tuning Criterion
In previous releases, the tuning tool would always try to find settings that minimize the optimality gap. You can use the new TuneCriterion parameter to search for settings that produce the best lower bound, upper bound, or gap.
Support for Python 3.5 on the Mac
With the addition of Python 3.5 support on the Mac, Gurobi Optimizer v7.0 now supports all of the most popular Python platforms. You can also now use Gurobi with the Anaconda Python 3.5 distribution for the Mac, with its large number of pre-built libraries to support full application development and included Jupyter Notebook development environment.
Additional Enhancements in 7.0
In addition to the above enhancements, we’ve also responded to requests for the following features:
- Enhanced .NET Property Support — Gurobi parameters and attributes are now available through .NET properties in the .NET interface.
- No more update calls for most programs — The new release changes the default update behavior. You can now refer to newly created variables and constraints without having to call update first.
- Additional new parameters:
- BestObjStop: New termination criterion – terminates a MIP solve when the incumbent objective is at least as good as the specified value.
- BestBdStop: New termination criterion – terminates a MIP solve when the best bound is at least as good as the specified value.
- InfProofCuts: New cutting plane type.
- StrongCGCuts: New cutting plane type.
- DegenMoves: Allows the user to shut off a root heuristic that can sometimes be expensive.
Enhancement Summary for 6.5
Gurobi 6.5 extends our growing tradition of providing significant performance enhancements with each new release. The performance highlights of this release include:
- MIP: 37% faster overall, and 72% faster on models that take more than 100 seconds to solve
- LP: 16% faster overall
- SOCP: 16% faster overall
- MIQP: 2X faster overall
- MIQCP: 2.8X faster overall
- Python API: expression building is more than 4X faster
While we’re seeing improvements on the majority of models in our test sets, results on your models may vary. We are happy to help you benchmark your models with Gurobi 6.5. Simply email us at firstname.lastname@example.org.
Our new release allows you to record the sequence of Gurobi commands issued by your program to a file and play them back later. This feature makes it much easier to debug performance issues, to identify leaks of Gurobi environments or models, or to relay the exact sequence of commands your program issued to Gurobi technical support (in case you run into an issue that is difficult to reproduce).
If you have a guess at a high quality solution for a MIP model (for example, from solving a related model), our new variable hint feature allows you to pass that guess to Gurobi. This information is used in the Gurobi heuristics and in branching to guide the search for a new solution. Providing a good guess will often produce a high quality solution much faster.
Gurobi 6.5 provides a new setting that allows you to avoid most calls to the update command, which can simplify your program. In particular, this new lazy update mode allows you to use new variables and constraints immediately, rather than having to wait until after you’ve called update.
Additional Enhancements in 6.5
In addition to the above enhancements, we’ve also responded to requests for the following features:
- Visual Studio 2015 support: Gurobi now supports the latest Visual Studio on Windows.
- C++11 support on Mac: Gurobi now supports the latest C++ compiler on Mac.
- More precise control of Gurobi environment creation and destruction in Python: you can now explicitly release an environment when you are done using it.
- Single-use license simplification: single-use licenses no longer require a token server.
- Token server password protection: you can now specify a password for your token server that must be provided by clients.
- Enhanced logging for distributed MIP: the distributed MIP log now contains nearly the same information as the single-machine MIP log.
- R interface enhancements: the R interface now supports SOS constraints, quadratic constraints, piecewise-linear objectives, and new solution statistics.
- New ‘OPB’ file reader: you can now read problems stored in pseudo-boolean file format.
With version 6.5, Gurobi continues to show its commitment to providing the best solvers, features, and support to help OR professionals succeed with optimization.
Enhancement Summary for 6.0
Consistent with Gurobi’s history of pushing solver performance levels forward, Gurobi 6.0 offers a broad range of performance improvements:
- MIP: 17% faster overall and 27% faster on difficult models that take more than 100s to solve
- LP: 6% faster overall – a notable improvement on our already #1 LP solver
- MIQP: 18% faster overall
- MIQCP: 28% faster overall
Obviously, each model is unique so your results may be better or worse than those shown above. We are happy to benchmark your model(s) using Gurobi 6.0.
Distributed MIP Solver
Gurobi users can now harness the power of multiple independent machines to solve a MIP model in parallel. You simply provide a list of machines that can be used as distributed workers, and Gurobi automatically distributes the work among the available machines. This new distributed MIP solver complements our existing distributed concurrent MIP solver and our distributed tuning tool.
Piecewise-Linear Objective Support
With Gurobi 6.0, you can now explicitly model piecewise-linear objective functions. Piecewise-linear objectives are handled directly by the simplex algorithm, so if you have a continuous model with a convex, piecewise-linear objective, you should see a significant performance boost from using this feature.
Additional Enhancements in v6.0
In addition to the above enhancements, we’ve also responded to requests for the following features:
- Concurrent LP solver: We’ve extended our existing distributed concurrent solver to support both LP and MIP models.
- Support for two billion non-zeros: You can now build and solve models whose constraint matrices have more than 2 billion non-zero values.
- Explicit support for Lazy constraints: You can use the new Lazy constraint attribute to mark constraints as lazy. Users can also now indicate that constraints should be treated as lazy in LP and MPS files.
- Other additions: New asynchronous optimization methods, a new scaling option, and more.
With version 6.0, Gurobi continues to show its commitment to providing the best solvers, features, and support to help OR professionals succeed with optimization.
Enhancement Summary for 5.6
Improved LP and MIP Performance
Consistent with our history of providing continual improvement with each version, we’re proud to announce that our new 5.6 release brings significant improvements for both LP and MIP models. Performance testing using our test library, consisting of literally thousands of models, shows significant improvements when measured over a broad range of models in our test set (models that require more than one second to solve), and even larger improvements for harder models (those that require more than 100 seconds to solve):
- LP — a 12% mean improvement in barrier performance for models in our broad test set, and a 21% mean improvement for harder models. Improvements are even larger on the new 4th generation Intel Core processors.
- MIP — a 14% mean improvement in time to proven optimality for models in our broad test set, and a 29% mean performance improvement for harder models.
Obviously, performance improvements will vary across models, with some showing less improvement than the increases listed above and others showing more. Please see our 5.6 Performance Benchmark deck for more details. As always, we are happy to assist you in obtaining the best possible results from this latest release of Gurobi.
In version 5.5, we introduced a new automatic parameter tuning tool to help users make more effective parameter choices with less effort. With 5.6 we are extending that capability to allow users to explore tuning options for a model not just on one machine, but on as many machines as they have available. This enables a dramatic increase in the amount of tuning exploration possible within a limited amount of time. What’s more, our tuning tool places no limit on the number of machines you can use. You just need one licensed Gurobi Compute Server (which could be a Gurobi Cloud system). Once you have this, you can enlist as many additional machines as you like to help with the distributed tuning task. You can learn more about how this is easily set up on our Distributed Optimization page.
Distributed Concurrent Optimization
Our new distributed concurrent optimization capability allows users to harness the power of multiple Gurobi Compute Servers to solve a single MIP model more quickly. Each machine works independently, trying different settings in order to introduce additional diversity into the MIP search. By bringing the resources of multiple machines to bear on a single model, this new feature often solves models much more quickly than a single machine alone. You can learn more on our Distributed Optimization page.
Additional Enhancements in 5.6
In addition to the above enhancements, we’ve also responded to user requests for the following features:
- Support for R 3.0 and Python 3.2
- MPS/LP file read and write capability from within MATLAB
- Additional user control — New parameters provide users more control over the strategies that Gurobi uses to solve models with SOS constraints or multiple, disconnected components.
- Additional user control of asynchronous optimization — When using Gurobi Compute Server to spawn multiple, asynchronous optimization jobs, the new Sync routine provides more explicit control over the synchronization of the simultaneous jobs.
With version 5.6, Gurobi continues to show its commitment to providing the best solvers, features, and support to help OR professionals succeed with optimization.
Enhancement Summary for 5.5
Our new Gurobi Compute Server feature provides an easier way for you to build client-server optimization applications. By transparently offloading the optimization computations from your client machines to one or more servers, this new capability allows you to make more efficient use of your compute resources. Gurobi Compute Server provides a number of features:
- Seamless integration of client-server capabilities into existing applications. Most programs that use Gurobi will run as client-server applications without any code changes at all.
- Powerful queuing and load balancing capabilities, with the ability to add server capacity on-the-fly.
- Automatic failover, which can significantly increase the reliability of your applications.
- Secure and efficient communication between the client and the server, including 256-bit AES encryption of your data
- Built-in administrative tools to monitor the health of your servers, examine the job queue, kill jobs, etc.
You can learn more on our Gurobi Compute Server Overview page.
Automatic Parameter Tuning Tool
The Gurobi Optimizer includes dozens of parameters that can be used to fine-tune the behavior of our optimization algorithms. For many models, parameter changes can improve performance by 50% or more. To help users make more effective parameter choices, version 5.5 includes a new automatic parameter tuning tool. This tool can be used as a stand-alone executable or called directly from the Gurobi programming language APIs. The new automatic tuning tool runs your model, gathers and analyzes performance information, and then performs a series of experiments with different parameter settings. When the tuning tool is finished, it provides several different parameter recommendations for you to try. The tuning tool includes a variety of configuration options that allow you to customize its behavior. You can learn more by reading the Automatic Parameter Tuning section of our Reference Manual.
Additional Enhancements in 5.5
In addition to the above enhancements, we’ve also responded to user requests for the following features:
- Concurrent MIP solver — This new MIP solution strategy performs several independent MIP solves in parallel, reporting the best results obtained by any of them. This approach is particularly effective on large parallel machines, where the benefit of performing a diverse set of solves is often significantly larger than the benefit of adding cores to a single MIP solve.
- Barrier crossover factorization improvements — We have rewritten the barrier crossover factorization routine. The new routine is both faster and more numerically robust.
- New NumericFocus parameter — This new parameter allows you to instruct the solver to use strategies that are more numerically robust (but slower).
- Numerical stability improvements — The new version includes a number of additional numerical stability improvements.
With version 5.5, Gurobi continues to show its commitment to providing the best solvers, features, and support to help OR professionals succeed with optimization.
Enhancement Summary for 5.1
Improved MIP Performance
Consistent with our history of continual performance improvements with each version, we’re proud to announce the following speed enhancements in 5.1:
- 5.4X mean improvement in time to first solution
- 15% mean improvement in time to proven optimality overall
- 40% improvement in time to optimality on the hardest models (those which take over 1,000 seconds to solve)
Obviously, performance improvements will vary across models, with some showing less improvement than the increases listed above and others showing more. As always, we are happy to assist you in obtaining the best possible results from this latest release of Gurobi.
In addition to delivering significant MIP performance improvements, we’ve also responded to user requests for the following features:
- Numerical robustness improvements in MIP presolve — enhancements in MIP presolve allow users to solve several numerically challenging models that previously couldn’t be solved.
- User control of the random number seed — users can now change the seed used for our internal random number generator. This introduces a perturbation to the solution process, which often produces a different computational path and can be useful for deciding whether a particular model or parameter change provides a robust performance improvement.
- MIP start files from the command line interface — the new InputFile parameter allows users to specify start files from the command line, making it much easier to experiment with MIP starts.
- Visual Studio 2012 support — including compatible object libraries as well as new Visual Studio projects for our full set of examples.
- New platform support — Windows 8, RHEL 6.3, SuSE 12, and Python 2.7 for Mac OS X.
With version 5.1, Gurobi continues to show its commitment to providing the best solvers, features, and support to help OR professionals succeed with optimization.
Enhancement Summary for 5.0
Now Supports Quadratic Constraints
Already the technology leader in LP, QP, and MIP, our new QCP and MIQCP solvers allow users to solve problems containing quadratic constraints. The new version supports second-order cones, rotated second-order cones, and more general convex quadratic constraints. Consistent with our goal of not just offering the features you need, but also providing the best available implementations, our new QCP and MIQCP solvers both provide more than twice the performance of the leading competitor.
Now Supports MATLAB and R
Providing tools that let our users work the way they want to work is important to us. As a result, with Version 5.0 we are expanding our available interfaces beyond the already strong support for C, C++, Python, Java, and .NET, to now also include full support for MATLAB and R. This should come as great news to the rapidly increasing numbers of users building statistical computing applications in R. Also, our new MATLAB interface gives MATLAB users access to a solver that is much more versatile and higher performance than the standard MATLAB offering. While there is already a good 3rd party open source MATLAB interface available, with 5.0 we’ve built one in to help more people get started faster due to its tighter integration, availability across a wider range of platforms, and included Gurobi technical support. Now Supports Lazy Constraints Some problems, like the prototypical traveling salesman problem, can have a virtually limitless number of constraints. This can make modeling them very difficult, if not impossible. With Version 5.0 we’ve added strong built-in support for lazy constraints to handle this situation. Now you can model your problem using a core set of constraints, to keep it manageable, and then during execution add additional constraints based on the set of solutions found. Consistent with how we treat all of Gurobi’s features, our lazy constraints don’t require you to shut off parallelism or change the fundamental approach used to explore the search tree.
Overall Performance Enhancements
In addition to solving more problem types and enhanced support for more interfaces, Version 5.0 also includes other feature and performance enhancements: Improved features for working with infeasible or unbounded models, including:
- A new barrier homogeneous algorithm specifically designed for infeasible problems
- New FeasRelax procedure for finding solutions that minimize constraint violations
Additional feature and performance enhancements, including the following:
- Faster presolve times
- Significant improvements in crossover numerical stability
- The ability to warm start simplex algorithms from primal plus dual solution vectors
- Enhanced user control of concurrent optimization
- A new approximate condition number algorithm
- The ability to retrieve variables and constraints by user-defined names
- With version 5.0, Gurobi continues to show its commitment to providing the best solvers, features, and support to help OR professionals succeed with optimization.
Enhancement Summary for 4.6
This release features enhanced Python modeling capabilities, significant improvements in primal simplex performance, improved MIP performance and robustness, and a new sifting algorithm for LP models that have many more variables than constraints. This update includes:
- An expanded Python modeling interface that makes it easier to build concise and efficient models. Substantial performance improvements in our primal simplex and MIQP solvers.
- Improved MIP performance as well as:
- Substantial improvements in MIP robustness: small tolerance violations are much less likely.
- A new sifting algorithm for LP models with many more variables than constraints.
- Support for user branching priorities in MIP.
- A new presolve sparsify option that can substantially reduce the difficulty of some MIP models.
- A new zero objective heuristic for finding feasible solutions to difficult MIP models.
- Support for reading .zip and .7zip files
Enhancement Summary for 4.5
The Gurobi Optimizer 4.5 continues to outperform other optimization solvers on important industry benchmarks. Gurobi consistently solves optimization models faster than either CPLEX or XPRESS, whether using 1, 4, or 12 processing cores. In some benchmarks, Gurobi mean performance is more than 8 times that of the competition. In addition, when time limits are imposed on solution time, Gurobi often finds solutions where other solvers cannot. Faster solution times and greater reliability are important features in an optimization solver, leading to more useful results and increased user productivity. Professor Hans Mittelmann of Arizona State University publishes a set of standard benchmark results for a wide range of optimization solvers and optimization problem types. On eight different benchmarks, data is provided that allows one to compare the performance of the three leading commercial optimization solvers on linear and mixed-integer programming problems. When the full spectrum of benchmarks is considered, a clear picture emerges: Gurobi Optimizer 4.5 consistently outperforms CPLEX 18.104.22.168 and XPRESS 7.2. Details on these benchmarks can be found on Professor Mittelmann’s website, Benchmarks for Optimization Software. Gurobi dominates on mixed-integer-programming (MIP) benchmarks
- MIPLIB 2010: On this important new benchmark that measures the time to obtain proven optimal solutions for a set of 87 MIP models, Gurobi outperforms both CPLEX and XPRESS, whether using 1 or 12 CPU cores.
- Feasibility: In benchmark tests that measure how long it takes to find the first feasible solution to a MIP problem, Gurobi dominates the competition, finding solutions more than 3 times as fast as CPLEX on average and more than 8 times as fast as XPRESS.
- Infeasibility: Proving a MIP model has no feasible solution can be an important step in model development. Gurobi solves this problem 20% faster than CPLEX and 80% faster than XPRESS.
- Pathological: While Gurobi does not win this benchmark, Professor Mittelmann states: “This benchmark is not giving a representative impression of the relative performance of the codes”. The benchmark tests are presented simply to show that even the best MIP codes can exhibit pathologically bad behavior. Because the set of tested models changes frequently, the “winners” for this benchmark are subject to change.
- MIQP: In benchmark tests that measure performance on mixed-integer programming models with quadratic objective functions, Gurobi dominates the competition, solving these models more than twice as fast on average.
Enhancements Summary for 4.0
The Gurobi Optimizer 4.0 provides Quadratic Programming solvers, improved performance and many new features:
- New QP and MIQP solvers: New quadratic programming solvers let you to formulate and solve optimization models with convex quadratic objectives. For continuous quadratic programming (QP) problems, the new release includes primal and dual simplex QP algorithms as well as a parallel barrier QP solver. A deterministic, parallel branch-and-cut algorithm is available for solving mixed integer quadratic programming (MIQP) models. All deliver industry leading performance.
- Continued performance improvements in MIP, dual simplex, and barrier: Initial tests indicate performance speed-ups of roughly 15% for MIP, 10% for simplex, and 10% for barrier.
- Improved numerical robustness: Several improvements in numerical robustness lead to better handling of numerically difficult models when using the simplex, barrier, and MIP solvers.
- Concurrent LP: When this feature is enabled, the solver will automatically pick the best algorithm for solving a given LP model. Both deterministic and non-deterministic versions are available. The deterministic solver guarantees identical solution paths over multiple runs. The non-deterministic solver does not give this guarantee, though solution-path differences are relatively rare, and the overall performance of the non-deterministic version is superior to that of the deterministic solver.
- New delayed MIP strategy option: With this option, you can direct Gurobi to reset the MIP solution focus to improving the best feasible solution once a specified time limit or objective gap has been reached.
- Visual Studio 2010 support: On Microsoft Windows, you can now call Gurobi from the latest version of Visual Studio.
- More explicit control over floating license use in Java and .NET: You can now explicitly release a license token, rather than relying on the system garbage collector to release it for you.