|Platform (port)||Operating System||Compiler||Notes|
|Windows 10, 11, Windows Server 2012 R2, 2016, 2019, 2022||Visual Studio 2017-2022||Use gurobi_c++md2017.lib (e.g.) for C++|
|Red Hat Enterprise Linux 7 (and corresponding CentOS distribution), 8, and 9||GCC >= 4.8||Use libgurobi_g++5.2.a for newer C++ compilers|
|SUSE Enterprise Linux 12, 15|
|Ubuntu 18.04, 20.04, 22.04*|
|Amazon Linux 2|
64-bit universal2 (macos_universal2)
|11 (Big Sur), 12 (Monterey)||Xcode 12/13|
|Red Hat Enterprise Linux 7 (and corresponding CentOS distribution), 8, and 9||GCC >= 4.8|
|SUSE Enterprise Linux 12, 15|
|Ubuntu 20.04, 22.04|
|Amazon Linux 2|
|AIX 7.1, 7.2, 7.3||XL C/C++ 9||Due to limited Python support on AIX, this port does not include the Interactive Shell or the Python libraries.|
*On Ubuntu 22.04 for x86-64, user code that calls dlopen()/dlclose() to load/unload libgurobi100.so is known to fail. We have investigated the issue, and unfortunately we have not yet found a workaround.
Additional Supported Platform Information
Gurobi 10.0.0 supports the following language/platform versions:
|Python||3.7, 3.8, 3.9, 3.10, 3.11|
|JDK||8, 11, 17|
NuGet package for .NET
We now provide an official NuGet package for .NET users. You can find the package at https://www.nuget.org/packages/Gurobi.Optimizer. Additional information is available in the .NET Interface section of the Gurobi Quick Start Guide.
Changed in Gurobi 10.0
Changes to C API
The parameter for method GRBcbproceed has changed. The signature was:
int GRBcbproceed(GRBmodel *model)and is now:
int GRBcbproceed(void *cbdata)
Changes to attributes
The VBasis variable attribute for a fixed variable will now return either -1 (non-basic at lower bound) or -2 (non-basic at upper bound), depending on the sign of the reduced cost (it previously always returned -1).
Changes to callback
User callbacks could previously be called from a variety of Gurobi methods. They will now only be called from methods that solve an optimization model. The list of such methods of course includes optimize, but also feasRelax, computeIIS, and a few others.
End of support for Python 2.7
This version has dropped support for Python 2.7.
Only one set of C++ libraries for Windows
We now only ship a single set of C++ libraries (gurobi_c++md2017.lib, gurobi_c++mdd2017.lib, etc.), built with Visual Studio 2017. These are binary compatible with Visual Studio versions 2017-2022.
Removed GRBgetlogfile method
The C API method GRBgetlogfile has been removed. Use the LogFile parameter to obtain the name of the log file.
Removed legacy methods for creating Compute Server and Instant Cloud environments
The following legacy methods and constructors for creating Compute Server and Instant Cloud environments have been removed:
- C: GRBloadclientenv, GRBloadcloudenv
GRBEnv(const std::string& logfilename, const std::string& computeserver, const std::string& router, const std::string& password, const std::string& group, int CStlsInsecure, int priority, double timeout) GRBEnv(const std::string& logfilename, const std::string& accessID, const std::string& secretKey, const std::string& pool, int priority)
GRBEnv(String logFileName, String computeServer, String router, String password, String group, int CStlsInsecure, int priority, double timeout) GRBEnv(String logfilename, String accessID, String secretKey, String pool, int priority)
GRBEnv(string logfilename, string computeserver, string router, string password, string group, int CStlsInsecure, int priority, double timeout) GRBEnv(string logfilename, string accessID, string secretKey, string pool, int priority)
- gurobipy: Env.ClientEnv, Env.CloudEnv,
- Matlab and R: The env parameter to the Gurobi functions. See Matlab and R changes below for conversion details.
You should use the configuration parameters instead, which were introduced in Gurobi 8.0 to simplify this process.
New features affecting all APIs
The Gurobi Web License Service (WLS) previously only worked within containerized environments. With Gurobi 10.0, WLS licenses are also available that work outside of containers (on Windows, macOS and Linux), as well as in both types of environments.
New parameters The following parameters are new in Gurobi 10.0:
- NetworkAlg to control the network
- OBBT to control the
aggressiveness of Optimality-Based Bound Tightening.
- SoftMemLimit to limit the
total amount of memory available to an optimization (leading to a
graceful exit when the limit is hit).
- WLSTokenRefresh to
specify the refresh interval of a Web License Service token.
Logistic General Constraint
Added support for piecewise-linear approximation of the logistic function as a general constraint. With this feature, you can model the logistic function on problem variables and . As with all general constraints, you can control how fine-grained the piecewise-linear approximation should be. See the General Constraint section for more information.
Specific performance improvements
In addition to general performance improvements across all supported problem classes, we have added the following enhancements for specific problem types:
- Added a network simplex algorithm to speed up the solution of LPs with pure network structure.
- Added a new QUBO heuristic to improve our ability to quickly find good feasible solutions for Quadratic Unconstrained Boolean Optimization problems.
- Reorganized the concurrent LP solver to improve performance and reduce memory consumption.
- Significantly improved performance on MIP models that contain constraints that model neural networks with ReLU activation functions.
Behavior changes affecting the Python matrix-friendly API
With version 10.0 we have extended the capabilities of the existing MVar, MLinExpr, and MQuadExpr modeling classes and improved their behaviour in many respects. Some of the changes may cause incompatibilities with existing code that uses these objects, so we suggest that you read the following summary carefully and adapt your code accordingly.
More arithmetic operations supported
You can now perform point-wise multiplication involving combinations of matrix-friendly modeling objects and NumPy ndarrays. For example:
a = numpy.random.rand(3) x = model.addMVar(3) y = model.addMVar(3) # Add three linear constraints a[i]*x[i] = y[i] model.addConstr(a * x == y) # Add three quadratic constraints x[i]*y[i] = a[i] model.addConstr(x * y == a)
Arbitrary dimensions now supported
The classes MVar, MLinExpr, and MQuadExpr now support arbitrary numbers of dimensions. For example, you can now create 2-D matrix linear expressions:
A = numpy.random.rand(4,3) B = numpy.random.rand(4,2) X = model.addMVar((3,2)) # Add 8 linear constraints A[i, :] @ X[:, j] == B[i, j] model.addConstr(A @ X == B)
Dimensionality and consistency
The classes MVar, MLinExpr, and MQuadExpr now behave similarly to NumPy's ndarray when it comes to dimension handling. For example:
X = model.addMVar((3,3)) sub1 = X[:, 1] # Gives 1-D (3,) Mvar sub2 = X[:, 1:2] # Gives 2-D (3, 1) Mvar sub3 = X[0, 1] # Gives 0-D () Mvar
In addition, a 0-D MVar object now acts like a “scalar” Var object, but it keeps its dimensionality properties.
Furthermore, in previous versions all MQuadExpr objects containing just one element had shape (1,). Such objects now follow the shape rules of Python's matrix multiplication operator:
Q = np.random.rand((3,3)); Q = Q + Q.T x = model.addMVar((3,1)) expr1 = x.T @ Q @ x # expr1.shape is (1,1) expr2 = x[:, 0] @ Q @ x[:, 0] # expr2.shape is ()
Arithmetic operations embrace NumPy's broadcasting rules
The behaviour of arithmetic operations among the matrix friendly modeling objects of different shapes now follows NumPy's broadcasting rules. For example:
a = numpy.random.rand(3) x = model.addMVar((3,3)) # a is broadcast along the first dimension of x; result is (3,3) expr = a * x
Broadcasting is also applied implicitly when adding broadcastable expressions as constraints:
a = numpy.random.rand(3) x = model.addMVar((3,3)) # a is broadcast along the first dimension of x. # The effect is the same as doing addConstr(x - a == 0) model.addConstr(x == a)
For detailed information on broadcasting we refer you to NumPy's documentation.
- Creating MVar objects through Model.addMVar is now
roughly 40% faster.
- The optional attribute initializers for Model.addMVar now
need to be passed in a broadcastable shape. In older versions, any
list with an appropriate number of elements could be used, which is
ambiguous in the case of a multi-dimensional MVar. Please refer to
the documentation of
- Using the MVar constructor to convert a list of Var
objects to an MVar object is deprecated. A dedicated, faster
method (MVar.fromlist) has
been introduced for this purpose.
- The method MVar.sum now
takes an optional axis argument to select an axis along which
the summation should happen. Also, the shape of the resulting
MLinExpr after summing all elements is now (),
(0-D), as opposed to (1,) in older versions.
- The method
MLinExpr.copy now returns
a deep copy, as opposed to a shallow copy in earlier versions.
- Invalid or incompatible matrix multiplication invocations now
raise a ValueError instead of a GurobiError.
To check whether your program calls any deprecated methods you can set an appropriate filter in Python's warnings module. For example, you can turn all warnings to runtime errors by starting the Python interpreter with the option -W error.
The env argument to Matlab and R API functions has been removed. This argument was previously used to provide the data required to connect to a Compute Server or to Gurobi Instant Cloud. This information should now be passed through parameters in the params struct.
For example, the new signature of the "gurobi" function is gurobi(model, params). To update a program that uses the env argument, just set the appropriate parameters in params to match the fields you previously used in env. The following table shows the correspondence between the field names of the deprecated env argument and Gurobi parameters:
A client MATLAB program that solves a model on a Compute Server should now look something like the following:
m.A = sparse(0,0); % Just a minimal model struct for demonstration params.Method = 2; % Use barrier method (for demonstration) params.ComputeServer = 'myserver.mycompany.com'; % Set server name params.ServerPassword = 'pass'; % Set password gurobi(m, params); % Solve model on server with barrier
Similarly for R, client code to solve a model on a Compute Server should look like:
m <- list(A = matrix(0)) # Just a minimal model struct for demonstration params <- list() params$Method <- 2 # Use barrier method (for demonstration) params$ComputeServer <- "myserver.mycompany.com"; # Set server name params$ServerPassword <- "pass"; # Set password gurobi(m, params); # Solve model on server with barrier
In summary, this is now the full list of signatures for Matlab and R API functions:
gurobi(model, params) gurobi_feasrelax(model, relaxobjtype, minrelax, penalties, params) gurobi_iis(model, params) gurobi_read(filename, params) gurobi_relax(model, params) gurobi_write(model, filename, params)
Compute Server, Cluster Manager, and Instant Cloud
Detailed release notes for Compute Server, Cluster Manager, and Instant Cloud can be found here