Use options to capture parameters (i.e.: configurations) for the run. The ModelOptions class captures the native gurobipy parameters, and the to_nextmv() method allows you to convert them to nextmv options, for convenience.
$ python main.py --help
usage: main.py [options]
Options for main.py. Use command-line arguments (highest precedence) or
environment variables.
options:
-h, --help show this help message and exit
-AggFill AGGFILL, --AggFill AGGFILL
[env var: AGGFILL] (default: -1) (type: int): Controls
the amount of fill allowed during presolve
aggregation. Larger values generally lead to presolved
models with fewer rows and columns, but with more
constraint matrix non-zeros. The default value chooses
automatically, and usually works well.
-Aggregate AGGREGATE, --Aggregate AGGREGATE
[env var: AGGREGATE] (default: 1) (type: int):
Controls the aggregation level in presolve. The
options are off (0), moderate (1), or aggressive (2).
In rare instances, aggregation can lead to an
accumulation of numerical errors. Turning it off can
sometimes improve solution accuracy.
-BQPCuts BQPCUTS, --BQPCuts BQPCUTS
[env var: BQPCUTS] (default: -1) (type: int): Controls
Boolean Quadric Polytope (BQP) cut generation. Use 0
to disable these cuts, 1 for moderate cut generation,
or 2 for aggressive cut generation. The default -1
value chooses automatically. Overrides the Cuts
parameter. Note: Only affects mixed integer
programming (MIP) models
-BarConvTol BARCONVTOL, --BarConvTol BARCONVTOL
[env var: BARCONVTOL] (default: 1e-08) (type: float):
The barrier solver terminates when the relative
difference between the primal and dual objective
values is less than the specified tolerance (with a
"GRB_OPTIMAL" status). Tightening this tolerance often
produces a more accurate solution, which can sometimes
reduce the time spent in crossover. Be aware that such
tightening may result in an increase of barrier
iterations and hence computation time spent therein.
Loosening it causes the barrier algorithm to terminate
with a less accurate solution, which can be useful
when barrier is making very slow progress in later
iterations. Note: Barrier only
-BarCorrectors BARCORRECTORS, --BarCorrectors BARCORRECTORS
[env var: BARCORRECTORS] (default: -1) (type: int):
Limits the number of central corrections performed in
each barrier iteration. The default value chooses
automatically, depending on problem characteristics.
The automatic strategy generally works well, although
it is often possible to obtain higher performance on a
specific model by selecting a value manually. Note:
Barrier only
-BarHomogeneous BARHOMOGENEOUS, --BarHomogeneous BARHOMOGENEOUS
[env var: BARHOMOGENEOUS] (default: -1) (type: int):
Determines whether to use the homogeneous barrier
algorithm. At the default setting (-1), it is only
used when barrier solves a node relaxation for a MIP
model. Setting the parameter to 0 turns it off, and
setting it to 1 forces it on. The homogeneous
algorithm is useful for recognizing infeasibility or
unboundedness. It is a bit slower than the default
algorithm. Note: Barrier only
-BarIterLimit BARITERLIMIT, --BarIterLimit BARITERLIMIT
[env var: BARITERLIMIT] (default: 1000) (type: int):
Limits the number of barrier iterations performed.
This parameter is rarely used. If you would like
barrier to terminate early, it is almost always better
to use the BarConvTol parameter instead. Optimization
returns with an ITERATION_LIMIT status if the limit is
exceeded. This parameter is callback settable. It can
be changed from within a callback when the "where"
value is "PRESOLVED", "SIMPLEX", "MIP", "MIPSOL",
"MIPNODE", "BARRIER", or "MULTIOBJ" (see the Callback
Codes section for more information). How to do that
for the different APIs is illustrated here. In case of
a remote server, the change of a parameter from within
a callback may not be taken into account immediately.
Note: Barrier only
-BarOrder BARORDER, --BarOrder BARORDER
[env var: BARORDER] (default: -1) (type: int): Chooses
the barrier sparse matrix fill-reducing algorithm. A
value of 0 chooses Approximate Minimum Degree
ordering, while a value of 1 chooses Nested Dissection
ordering. The default value of -1 chooses
automatically. You should only modify this parameter
if you notice that the barrier ordering phase is
consuming a significant fraction of the overall
barrier runtime. Note: Barrier only
-BarQCPConvTol BARQCPCONVTOL, --BarQCPConvTol BARQCPCONVTOL
[env var: BARQCPCONVTOL] (default: 1e-06) (type:
float): When solving a QCP model, the barrier solver
terminates when the relative difference between the
primal and dual objective values is less than the
specified tolerance (with a "GRB_OPTIMAL" status).
Tightening this tolerance may lead to a more accurate
solution, but it may also lead to a failure to
converge. Note: Barrier only
-BestBdStop BESTBDSTOP, --BestBdStop BESTBDSTOP
[env var: BESTBDSTOP] (default: 1e+100) (type: float):
Terminates as soon as the engine determines that the
best bound on the objective value is at least as good
as the specified value. Optimization returns with an
USER_OBJ_LIMIT status in this case. Note that you
should always include a small tolerance in this value.
Without this, a bound that satisfies the intended
termination criterion may not actually lead to
termination due to numerical round- off in the bound.
Note: Only affects mixed integer programming (MIP)
models
-BestObjStop BESTOBJSTOP, --BestObjStop BESTOBJSTOP
[env var: BESTOBJSTOP] (default: -1e+100) (type:
float): Terminate as soon as the engine finds a
feasible solution whose objective value is at least as
good as the specified value. Optimization returns with
an USER_OBJ_LIMIT status in this case. Note that you
should always include a small tolerance in this value.
Without this, a solution that satisfies the intended
termination criterion may not actually lead to
termination due to numerical round- off in the
objective. Note: Only affects mixed integer
programming (MIP) models
-BranchDir BRANCHDIR, --BranchDir BRANCHDIR
[env var: BRANCHDIR] (default: 0) (type: int):
Determines which child node is explored first in the
branch-and-cut search. The default value chooses
automatically. A value of -1 will always explore the
down branch first, while a value of 1 will always
explore the up branch first. Changing the value of
this parameter rarely produces a significant benefit.
Note: Only affects mixed integer programming (MIP)
models
-CSAPIAccessID CSAPIACCESSID, --CSAPIAccessID CSAPIACCESSID
[env var: CSAPIACCESSID] (default: ) (type: str): A
unique identifier used to authenticate an application
on a Gurobi Cluster Manager. You can provide either an
access ID and a secret key, or a username and
password, to authenticate your connection to a Cluster
Manager. You must set this parameter through either a
"gurobi.lic" file (using "CSAPIACCESSID=YOUR_API_ID")
or an empty environment. Changing the parameter after
your environment has been started will result in an
error. Note: Cluster Manager only
-CSAPISecret CSAPISECRET, --CSAPISecret CSAPISECRET
[env var: CSAPISECRET] (default: ) (type: str): The
secret password associated with an API access ID. You
can provide either an access ID and a secret key, or a
username and password, to authenticate your connection
to a Cluster Manager. You must set this parameter
through either a "gurobi.lic" file (using
"CSAPISECRET=YOUR_API_SECRET_KEY") or an empty
environment. Changing the parameter after your
environment has been started will result in an error.
Note: Cluster Manager only
-CSAppName CSAPPNAME, --CSAppName CSAPPNAME
[env var: CSAPPNAME] (default: ) (type: str): The
application name which will be sent to the server to
track which application is submitting the batches or
jobs. Note: Cluster Manager only
-CSAuthToken CSAUTHTOKEN, --CSAuthToken CSAUTHTOKEN
[env var: CSAUTHTOKEN] (default: ) (type: str): When a
client authenticates with a Cluster Manager using a
username and password, a signed token is returned by
the server to be used in further calls or command-line
operations. It is used internally. Note: Cluster
Manager only
-CSBatchMode CSBATCHMODE, --CSBatchMode CSBATCHMODE
[env var: CSBATCHMODE] (default: 0) (type: int): When
set to 1, enable the local creation of models, and
later submit batch-optimization jobs to the Cluster
Manager. See the Batch Optimization section for more
details. Note that if CSBatchMode is enabled, only
batch-optimization calls are allowed. You must set
this parameter through either a "gurobi.lic" file
(using "CSBATCHMODE=1") or an empty environment.
Changing the parameter after your environment has been
started will result in an error. Note: Cluster Manager
only
-CSClientLog CSCLIENTLOG, --CSClientLog CSCLIENTLOG
[env var: CSCLIENTLOG] (default: 0) (type: int): Turns
logging on or off for Compute Server and the Web
License Service (WLS). Options are off (0), only error
messages (1), information and error messages (2), or
(3) verbose, information, and error messages.
-CSGroup CSGROUP, --CSGroup CSGROUP
[env var: CSGROUP] (default: ) (type: str): Specifies
one or more groups of cluster nodes to control the
placement of the job. The list is a comma-separated
string of group names, with optionally a priority for
a group. For example, specifying "group1:10,group2:50"
means that the job will run on machines of "group1" or
"group2", and if the job is queued, it will have
priority 10 on group1 and 50 on group2. Note that if
the group is not specified, the job may run on any
node. If there are no nodes in the cluster having the
specified groups, the job will be rejected. Refer to
the *Gurobi Remote Services Reference Manual* for more
information on starting Compute Server jobs and in
particular to *Gurobi Remote Services Cluster
Grouping* for more information on grouping cluster
nodes. You must set this parameter through either a
license file (using "GROUP=name") or an empty
environment. Changing the parameter after your
environment has been created will have no effect.
-CSIdleTimeout CSIDLETIMEOUT, --CSIdleTimeout CSIDLETIMEOUT
[env var: CSIDLETIMEOUT] (default: -1) (type: int):
This parameter allows you to set a limit on how long a
Compute Server job can sit idle before the server
kills the job (in seconds). A job is considered idle
if the server is not currently performing an
optimization and the client has not issued any
additional commands. The default value will allow a
job to sit idle indefinitely in all but one
circumstance. Currently the only exception is the
Gurobi Instant Cloud, where the default setting will
automatically impose a 30 minute idle time limit (1800
seconds). If you are using an Instant Cloud pool, the
actual value will be the maximum between this
parameter value and the idle timeout defined by the
pool. You must set this parameter through either a
"gurobi.lic" file (using "IDLETIMEOUT=n") or an empty
environment. Changing the parameter after your
environment has been created will have no effect.
Refer to the *Gurobi Remote Services Reference Manual*
for more information on starting Compute Server jobs.
-CSManager CSMANAGER, --CSManager CSMANAGER
[env var: CSMANAGER] (default: ) (type: str): URL of
the Cluster Manager for the Remote Services cluster.
You must set this parameter through either a
"gurobi.lic" file (using "CSMANAGER=YOUR_MANAGER_URL")
or an empty environment. Changing the parameter after
your environment has been started will result in an
error. Note: Cluster Manager only
-CSPriority CSPRIORITY, --CSPriority CSPRIORITY
[env var: CSPRIORITY] (default: 0) (type: int): The
priority of the Compute Server job. Priorities must be
between -100 and 100, with a default value of 0 (by
convention). Higher priority jobs are chosen from the
server job queue before lower priority jobs. A job
with priority 100 runs immediately, bypassing the job
queue and ignoring the job limit on the server. You
should exercise caution with priority 100 jobs, since
they can severely overload a server, which can cause
jobs to fail, and in extreme cases can cause the
server to crash. Refer to the *Gurobi Remote Services
Reference Manual* for more information on starting
Compute Server jobs. You must set this parameter
through either a "gurobi.lic" file (using
"PRIORITY=n") or an empty environment. Changing the
parameter after your environment has been created will
have no effect.
-CSQueueTimeout CSQUEUETIMEOUT, --CSQueueTimeout CSQUEUETIMEOUT
[env var: CSQUEUETIMEOUT] (default: -1.0) (type:
float): This parameter allows you to set a limit (in
seconds) on how long a new Compute Server job will
wait in queue before it gives up (and reports a
"JOB_REJECTED" error). Note that there might be a
delay of up to 20 seconds for the actual signaling of
the time out. Any negative value will allow a job to
sit in the Compute Server queue indefinitely. You must
set this parameter through a "gurobi.lic" file (using
"QUEUETIMEOUT=n") or an empty environment. Changing
the parameter after your environment has been created
will have no effect. Refer to the *Gurobi Remote
Services Reference Manual* for more information on
starting Compute Server jobs.
-CSRouter CSROUTER, --CSRouter CSROUTER
[env var: CSROUTER] (default: ) (type: str): The
router node for a Remote Services cluster. A router
can be used to improve the robustness of a Compute
Server deployment. You can refer to the router using
either its name or its IP address. A typical Remote
Services deployment won’t use a router, so you
typically won’t need to set this parameter. Refer to
the *Gurobi Remote Services Reference Manual* for more
information on starting Compute Server jobs. You must
set this parameter through either a "gurobi.lic" file
(using "ROUTER=name") or an empty environment.
Changing the parameter after your environment has been
created will have no effect.
-CSTLSInsecure CSTLSINSECURE, --CSTLSInsecure CSTLSINSECURE
[env var: CSTLSINSECURE] (default: 0) (type: int):
Indicates whether the Remote Services cluster is using
insecure mode in the TLS (Transport Layer Security).
Leave this at its default value of 0 unless your
server administrator tells you otherwise. Refer to the
*Gurobi Remote Services Reference Manual* for more
information on starting Compute Server jobs. You must
set this parameter through either a "gurobi.lic" file
(using "CSTLSINSECURE") or an empty environment.
Changing the parameter after your environment has been
created will have no effect.
-CliqueCuts CLIQUECUTS, --CliqueCuts CLIQUECUTS
[env var: CLIQUECUTS] (default: -1) (type: int):
Controls clique cut generation. Use 0 to disable these
cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value choose
automatically. Overrides the Cuts parameter. We have
observed that setting this parameter to its aggressive
setting can produce a significant benefit for some
large set partitioning models. Note: Only affects
mixed integer programming (MIP) models
-CloudAccessID CLOUDACCESSID, --CloudAccessID CLOUDACCESSID
[env var: CLOUDACCESSID] (default: ) (type: str): Set
this parameter to the Access ID for your Instant Cloud
license when launching a new instance. You can
retrieve this string from your account on the Gurobi
Instant Cloud Manager website. You must set this
parameter through either a "gurobi.lic" file (using
"CLOUDACCESSID=id") or an empty environment. Changing
the parameter after your environment has been created
will have no effect.
-CloudHost CLOUDHOST, --CloudHost CLOUDHOST
[env var: CLOUDHOST] (default: ) (type: str): Set this
parameter to the host name of the Gurobi Cloud entry
point. Currently "cloud.gurobi.com". You must set this
parameter through either a "gurobi.lic" file (using
"CLOUDHOST=host") or an empty environment. Changing
the parameter after your environment has been started
will result in an error.
-CloudPool CLOUDPOOL, --CloudPool CLOUDPOOL
[env var: CLOUDPOOL] (default: ) (type: str): Set this
parameter to the name of the cloud pool you would like
to use for your new Instant Cloud instance. You can
browse your existing cloud pools or create new ones
from your account on the Gurobi Instant Cloud Manager
website. You must set this parameter through either a
"gurobi.lic" file (using "CLOUDPOOL=pool") or an empty
environment. Changing the parameter after your
environment has been created will have no effect.
-CloudSecretKey CLOUDSECRETKEY, --CloudSecretKey CLOUDSECRETKEY
[env var: CLOUDSECRETKEY] (default: ) (type: str): Set
this parameter to the Secret Key for your Instant
Cloud license when launching a new instance. You can
retrieve this string from your account on the Gurobi
Instant Cloud Manager website. You must set this
parameter through either a "gurobi.lic" file (using
"CLOUDSECRETKEY=key") or an empty environment.
Changing the parameter after your environment has been
created will have no effect.
-ComputeServer COMPUTESERVER, --ComputeServer COMPUTESERVER
[env var: COMPUTESERVER] (default: ) (type: str): Set
this parameter to the name of a node in the Remote
Services cluster where you’d like your Compute Server
job to run. You can refer to the server using its name
or its IP address. If you are using a non-default
port, the server name should be followed by the port
number (e.g., "server1:61000"). You will also need to
set the ServerPassword parameter to supply the client
password for the specified cluster. You can provide a
comma-separated list of nodes to increase robustness.
If the first node in the list doesn’t respond, the
second will be tried, etc. Refer to the *Gurobi Remote
Services Reference Manual* for more information on
starting Compute Server jobs. You must set this
parameter through either a "gurobi.lic" file (using
"COMPUTESERVER=server") or an empty environment.
Changing the parameter after your environment has been
created will have no effect.
-ConcurrentJobs CONCURRENTJOBS, --ConcurrentJobs CONCURRENTJOBS
[env var: CONCURRENTJOBS] (default: 0) (type: int):
Enables distributed concurrent optimization, which can
be used to solve LP or MIP models on multiple
machines. A value of "n" causes the solver to create
"n" independent models, using different parameter
settings for each. Each of these models is sent to a
distributed worker for processing. Optimization
terminates when the first solve completes. Use the
ComputeServer parameter to indicate the name of the
cluster where you would like your distributed
concurrent job to run (or use WorkerPool if your
client machine will act as manager and you just need a
pool of workers). By default, Gurobi chooses the
parameter settings used for each independent solve
automatically. You can create concurrent environments
to choose your own parameter settings (refer to the
concurrent optimization section for details). The
intent of concurrent MIP solving is to introduce
additional diversity into the MIP search. By bringing
the resources of multiple machines to bear on a single
model, this approach can sometimes solve models much
faster than a single machine. The distributed
concurrent solver produces a slightly different log
from the standard solver, and provides different
callbacks as well. Please refer to the "Distributed
Algorithms" section of the *Gurobi Remote Services
Reference Manual* for additional details.
-ConcurrentMIP CONCURRENTMIP, --ConcurrentMIP CONCURRENTMIP
[env var: CONCURRENTMIP] (default: 1) (type: int):
This parameter enables the concurrent MIP solver. When
the parameter is set to value "n", the MIP solver
performs "n" independent MIP solves in parallel, with
different parameter settings for each. Optimization
terminates when the first solve completes. By default,
Gurobi chooses the parameter settings used for each
independent solve automatically. You can create
concurrent environments to choose your own parameter
settings (refer to the concurrent optimization section
for details). The intent of concurrent MIP solving is
to introduce additional diversity into the MIP search.
This approach can sometimes solve models much faster
than applying all available threads to a single MIP
solve, especially on very large parallel machines. The
concurrent MIP solver divides available threads evenly
among the independent solves. For example, if you have
6 threads available and you set ConcurrentMIP to 2,
the concurrent MIP solver will allocate 3 threads to
each independent solve. Note that the number of
independent solves launched will not exceed the number
of available threads. The concurrent MIP solver
produces a slightly different log from the standard
MIP solver, and provides different callbacks as well.
Please refer to the concurrent optimizer discussion
for additional details. Concurrent MIP is not
deterministic. If runtimes for different independent
solves are very similar, and if the model has multiple
optimal solutions, you may get slightly different
results from multiple runs on the same model. Note:
Only affects mixed integer programming (MIP) models
-ConcurrentMethod CONCURRENTMETHOD, --ConcurrentMethod CONCURRENTMETHOD
[env var: CONCURRENTMETHOD] (default: -1) (type: int):
This parameter is only evaluated when solving an LP
with a concurrent solver (Method = 3 or 4). It
controls which methods are run concurrently by the
concurrent solver. Options are: * -1=automatic, *
0=barrier, dual, primal simplex, * 1=barrier and dual
simplex, * 2=barrier and primal simplex, and * 3=dual
and primal simplex. Which methods are actually run
also depends on the number of threads available.
-CoverCuts COVERCUTS, --CoverCuts COVERCUTS
[env var: COVERCUTS] (default: -1) (type: int):
Controls cover cut generation. Use 0 to disable these
cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-Crossover CROSSOVER, --Crossover CROSSOVER
[env var: CROSSOVER] (default: -1) (type: int):
Determines the crossover strategy used to transform
the interior solution produced by barrier into a basic
solution (note that crossover is not available for QP
or QCP models). Crossover consists of three phases:
(i) a *primal push* phase, where primal variables are
pushed to bounds, (ii) a *dual push* phase, where dual
variables are pushed to bounds, and (iii) a *cleanup*
phase, where simplex is used to remove any primal or
dual infeasibilities that remain after the push phases
are complete. The order of the first two phases and
the algorithm used for the third phase are both
controlled by the Crossover parameter: +--------------
-------+----------------+-----------------+-----------
--+ | **Parameter value** | **First push** | **Second
push** | **Cleanup** | |=====================|========
========|=================|=============| | 0 |
Disabled | Disabled | Disabled | +--------------------
-+----------------+-----------------+-------------+ |
1 | Dual | Primal | Primal | +---------------------+--
--------------+-----------------+-------------+ | 2 |
Dual | Primal | Dual | +---------------------+--------
--------+-----------------+-------------+ | 3 | Primal
| Dual | Primal | +---------------------+-------------
---+-----------------+-------------+ | 4 | Primal |
Dual | Dual | +---------------------+----------------
+-----------------+-------------+ The default value of
-1 chooses the strategy automatically. Use value 0 to
disable crossover; this setting returns the interior
solution computed by barrier. Note: Barrier only
-CrossoverBasis CROSSOVERBASIS, --CrossoverBasis CROSSOVERBASIS
[env var: CROSSOVERBASIS] (default: -1) (type: int):
Determines the initial basis construction strategy for
crossover. A value of 0 chooses an initial basis
quickly. A value of 1 can take much longer, but often
produces a more numerically stable start basis. The
default value of -1 makes an automatic choice. Note:
Barrier only
-CutAggPasses CUTAGGPASSES, --CutAggPasses CUTAGGPASSES
[env var: CUTAGGPASSES] (default: -1) (type: int): A
non-negative value indicates the maximum number of
constraint aggregation passes performed during cut
generation. Overrides the Cuts parameter. Changing the
value of this parameter rarely produces a significant
benefit. Note: Only affects mixed integer programming
(MIP) models
-CutPasses CUTPASSES, --CutPasses CUTPASSES
[env var: CUTPASSES] (default: -1) (type: int): A non-
negative value indicates the maximum number of cutting
plane passes performed during root cut generation. The
default value chooses the number of cut passes
automatically. In addition to cutting plane
separation, each cut pass also applies heuristics and
node probing and also may launch parallel root helper
threads. So even when the Cuts parameter is set to 0,
the cut loop will apply probing, heuristics and
parallel root helpers in a single cut loop iteration.
You should experiment with different values of this
parameter if you notice the MIP solver spending
significant time on root cut passes that have little
impact on the objective bound. Note: Only affects
mixed integer programming (MIP) models
-Cuts CUTS, --Cuts CUTS
[env var: CUTS] (default: -1) (type: int): Global cut
aggressiveness setting. Use value 0 to shut off cuts,
1 for moderate cut generation, 2 for aggressive cut
generation, and 3 for very aggressive cut generation.
The default -1 value chooses automatically. This
parameter is overridden by the parameters that control
individual cut types (e.g., CliqueCuts). Note: Only
affects mixed integer programming (MIP) models
-DegenMoves DEGENMOVES, --DegenMoves DEGENMOVES
[env var: DEGENMOVES] (default: -1) (type: int):
Limits degenerate simplex moves. These moves are
performed to improve the integrality of the current
relaxation solution. By default, the algorithm chooses
the number of degenerate move passes to perform
automatically. The default setting generally works
well, but there can be cases where an excessive amount
of time is spent after the initial root relaxation has
been solved but before the cut generation process or
the root heuristics have started. If you see multiple
‘Total elapsed time’ messages in the log immediately
after the root relaxation log, you may want to try
setting this parameter to 0. Note: Only affects mixed
integer programming (MIP) models
-Disconnected DISCONNECTED, --Disconnected DISCONNECTED
[env var: DISCONNECTED] (default: -1) (type: int): A
MIP or an LP model can sometimes be made up of
multiple, completely independent sub-models. This
parameter controls how aggressively we try to exploit
this structure. A value of 0 ignores this structure
entirely, while larger values try more aggressive
approaches. The default value of -1 chooses
automatically. Note: Only affects mixed integer
programming (MIP) models
-DisplayInterval DISPLAYINTERVAL, --DisplayInterval DISPLAYINTERVAL
[env var: DISPLAYINTERVAL] (default: 5) (type: int):
Determines the frequency at which log lines are
printed (in seconds).
-DistributedMIPJobs DISTRIBUTEDMIPJOBS, --DistributedMIPJobs DISTRIBUTEDMIPJOBS
[env var: DISTRIBUTEDMIPJOBS] (default: 0) (type:
int): Enables distributed MIP. A value of "n" causes
the MIP solver to divide the work of solving a MIP
model among "n" machines. Use the ComputeServer
parameter to indicate the name of the cluster where
you would like your distributed MIP job to run (or use
WorkerPool if your client machine will act as manager
and you just need a pool of workers). The distributed
MIP solver produces a slightly different log from the
standard MIP solver, and provides different callbacks
as well. Please refer to the "Distributed Algorithms"
section of the *Gurobi Remote Services Reference
Manual* for additional details. Note: Only affects
mixed integer programming (MIP) models
-DualImpliedCuts DUALIMPLIEDCUTS, --DualImpliedCuts DUALIMPLIEDCUTS
[env var: DUALIMPLIEDCUTS] (default: -1) (type: int):
Controls dual implied bound cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-DualReductions DUALREDUCTIONS, --DualReductions DUALREDUCTIONS
[env var: DUALREDUCTIONS] (default: 1) (type: int):
Determines whether dual reductions are performed
during the optimization process. You should disable
these reductions if you received an optimization
status of INF_OR_UNBD and would like a more definitive
conclusion.
-FeasRelaxBigM FEASRELAXBIGM, --FeasRelaxBigM FEASRELAXBIGM
[env var: FEASRELAXBIGM] (default: 1000000.0) (type:
float): When relaxing a constraint in a feasibility
relaxation, it is sometimes necessary to introduce a
big-M value. This parameter determines the default
magnitude of that value. For details about feasibility
relaxations, refer to e.g. "GRBfeasrelax" in the C
API.
-FeasibilityTol FEASIBILITYTOL, --FeasibilityTol FEASIBILITYTOL
[env var: FEASIBILITYTOL] (default: 1e-06) (type:
float): All constraints must be satisfied to a
tolerance of FeasibilityTol. Tightening this tolerance
can produce smaller constraint violations, but for
numerically challenging models it can sometimes lead
to much larger iteration counts.
-FlowCoverCuts FLOWCOVERCUTS, --FlowCoverCuts FLOWCOVERCUTS
[env var: FLOWCOVERCUTS] (default: -1) (type: int):
Controls flow cover cut generation. Use 0 to disable
these cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-FlowPathCuts FLOWPATHCUTS, --FlowPathCuts FLOWPATHCUTS
[env var: FLOWPATHCUTS] (default: -1) (type: int):
Controls flow path cut generation. Use 0 to disable
these cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-FuncMaxVal FUNCMAXVAL, --FuncMaxVal FUNCMAXVAL
[env var: FUNCMAXVAL] (default: 1000000.0) (type:
float): Very large values in piecewise-linear
approximations can cause numerical issues. This
parameter limits the bounds on the variables that
participate in function constraints approximated by a
piecewise- linear function. Specifically, any bound
larger than "FuncMaxVal" (in absolute value) on the
variables participating in such a function constraint
will be truncated. If the FuncNonlinear attribute of
the constraint is set to 1, or if it is set to -1 and
the global FuncNonlinear parameter is set to 1, the
function constraint is not approximated by a
piecewise-linear function and the "FuncMaxVal"
parameter does not apply.
-FuncNonlinear FUNCNONLINEAR, --FuncNonlinear FUNCNONLINEAR
[env var: FUNCNONLINEAR] (default: 1) (type: int):
This parameter controls whether general function
constraints with their FuncNonlinear attribute set to
-1 are replaced with a static piecewise-linear
approximation (0), or handled inside the branch-and-
bound tree using a dynamic outer-approximation
approach (1). See the discussion of function
constraints for more information.
-FuncPieceError FUNCPIECEERROR, --FuncPieceError FUNCPIECEERROR
[env var: FUNCPIECEERROR] (default: 0.001) (type:
float): If the FuncPieces parameter is set to value -1
or -2, this attribute provides the maximum allowed
error (absolute for -1, relative for -2) in the
piecewise-linear approximation.
-FuncPieceLength FUNCPIECELENGTH, --FuncPieceLength FUNCPIECELENGTH
[env var: FUNCPIECELENGTH] (default: 0.01) (type:
float): If the FuncPieces parameter is set to value 1,
this parameter gives the length of each piece of the
piecewise-linear approximation.
-FuncPieceRatio FUNCPIECERATIO, --FuncPieceRatio FUNCPIECERATIO
[env var: FUNCPIECERATIO] (default: -1.0) (type:
float): This parameter controls whether the piecewise-
linear approximation of a function constraint is an
underestimate of the function, an overestimate, or
somewhere in between. A value of 0.0 will always
underestimate, while a value of 1.0 will always
overestimate. A value in between will interpolate
between the underestimate and the overestimate. A
special value of -1 chooses points that are on the
original function. The behaviour is not defined for
other negative values. See the discussion of function
constraints for more information.
-FuncPieces FUNCPIECES, --FuncPieces FUNCPIECES
[env var: FUNCPIECES] (default: 0) (type: int): This
parameter sets the strategy used for performing a
piecewise- linear approximation of a function
constraint. There are a few options: * **FuncPieces >=
2**: Sets the number of pieces; pieces are equal
width. * **FuncPieces = 1**: Uses a fixed width for
each piece; the actual width is provided in the
FuncPieceLength parameter. * **FuncPieces = 0**:
Default value; chooses automatically. Currently it
uses the relative error approach for the
approximation, while for version 10.0 or earlier it
mainly uses the number of function constraints to set
the total number of pieces. * **FuncPieces = -1**:
Bounds the absolute error of the approximation; the
error bound is provided in the FuncPieceError
parameter. * **FuncPieces = -2**: Bounds the relative
error of the approximation; the error bound is
provided in the FuncPieceError parameter. This
parameter only applies to function constraints whose
FuncPieces attribute has been set to 0. See the
discussion of function constraints for more
information.
-GUBCoverCuts GUBCOVERCUTS, --GUBCoverCuts GUBCOVERCUTS
[env var: GUBCOVERCUTS] (default: -1) (type: int):
Controls GUB cover cut generation. Use 0 to disable
these cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-GomoryPasses GOMORYPASSES, --GomoryPasses GOMORYPASSES
[env var: GOMORYPASSES] (default: -1) (type: int): A
non-negative value indicates the maximum number of
Gomory cut passes performed. Overrides the Cuts
parameter. Note: Only affects mixed integer
programming (MIP) models
-Heuristics HEURISTICS, --Heuristics HEURISTICS
[env var: HEURISTICS] (default: 0.05) (type: float):
Determines the amount of time spent in MIP heuristics.
You can think of the value as the desired fraction of
total MIP runtime devoted to heuristics (so by
default, we aim to spend 5% of runtime on heuristics).
Larger values produce more and better feasible
solutions, at a cost of slower progress in the best
bound. Note: Only affects mixed integer programming
(MIP) models
-IISMethod IISMETHOD, --IISMethod IISMETHOD
[env var: IISMETHOD] (default: -1) (type: int):
Chooses the IIS method to use. To compute an IIS for
an LP, it is sufficient to solve an LP with dimensions
similar to the dual of the original model. If the
solve time for that LP is excessive, setting the
IISMethod parameter to 1 may offer a faster
alternative; other settings do not alter the default
approach for infeasible LPs. For MIPs, filtering of
constraints and variables is required, which involves
solving a series of related MIP subproblems. Methods
0-2 all use filtering techniques. Method 0 is often
faster than method 1, but may produce a larger IIS.
Method 2 ignores the bound constraints. It therefore
tends to be faster than methods 0-1, but will fail if
these bounds are necessary to make the problem
infeasible. Method 3 will return the IIS for the LP
relaxation of a MIP model if the relaxation is
infeasible, even though the result may not be minimal
when integrality constraints are included. The default
value of -1 chooses automatically.
-IgnoreNames IGNORENAMES, --IgnoreNames IGNORENAMES
[env var: IGNORENAMES] (default: 0) (type: int): This
parameter affects how Gurobi deals with names. If set
to 1, subsequent calls to add variables or constraints
to the model will ignore the associated names. Names
for objectives and the model will also be ignored. In
addition, subsequent calls to modify name attributes
will have no effect. Note that variables or
constraints that had names at the point this parameter
was changed to 1 will retain their names. If you wish
to discard all name information, you should set this
parameter to 1 before adding variables or constraints
to the model. In addition, the parameter affects the
behavior of the write functions (e.g. "GRBwrite" in C,
or "Model.write" in Python). If "IgnoreNames" is set
to 1, Gurobi uses default names when writing the file.
This can be useful if you have a model with names and
want to write the model, the attributes, a MIP start
file, or other information to disk without including
variable and constraint names in the files.
-ImpliedCuts IMPLIEDCUTS, --ImpliedCuts IMPLIEDCUTS
[env var: IMPLIEDCUTS] (default: -1) (type: int):
Controls implied bound cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-ImproveStartGap IMPROVESTARTGAP, --ImproveStartGap IMPROVESTARTGAP
[env var: IMPROVESTARTGAP] (default: 0.0) (type:
float): The MIP solver can change parameter settings
in the middle of the search in order to adopt a
strategy that gives up on moving the best bound and
instead devotes all of its effort towards finding
better feasible solutions. This parameter allows you
to specify an optimality gap at which the MIP solver
switches to a solution improvement strategy. For
example, setting this parameter to 0.1 will cause the
MIP solver to switch strategies once the relative
optimality gap is smaller than 0.1. Note: Only affects
mixed integer programming (MIP) models
-ImproveStartNodes IMPROVESTARTNODES, --ImproveStartNodes IMPROVESTARTNODES
[env var: IMPROVESTARTNODES] (default: 1e+100) (type:
float): The MIP solver can change parameter settings
in the middle of the search in order to adopt a
strategy that gives up on moving the best bound and
instead devotes all of its effort towards finding
better feasible solutions. This parameter allows you
to specify the node count at which the MIP solver
switches to a solution improvement strategy. For
example, setting this parameter to 10 will cause the
MIP solver to switch strategies once the node count is
larger than 10. Note: Only affects mixed integer
programming (MIP) models
-ImproveStartTime IMPROVESTARTTIME, --ImproveStartTime IMPROVESTARTTIME
[env var: IMPROVESTARTTIME] (default: 1e+100) (type:
float): The MIP solver can change parameter settings
in the middle of the search in order to adopt a
strategy that gives up on moving the best bound and
instead devotes all of its effort towards finding
better feasible solutions. This parameter allows you
to specify the time when the MIP solver switches to a
solution improvement strategy. For example, setting
this parameter to 10 will cause the MIP solver to
switch strategies 10 seconds after starting the
optimization. Note: Only affects mixed integer
programming (MIP) models
-InfProofCuts INFPROOFCUTS, --InfProofCuts INFPROOFCUTS
[env var: INFPROOFCUTS] (default: -1) (type: int):
Controls infeasibility proof cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-InfUnbdInfo INFUNBDINFO, --InfUnbdInfo INFUNBDINFO
[env var: INFUNBDINFO] (default: 0) (type: int): Set
this parameter if you want to query the unbounded ray
for unbounded models (through the UnbdRay attribute),
or the infeasibility proof for infeasible models
(through the FarkasDual and FarkasProof attributes).
When this parameter is set additional information will
be computed when a model is determined to be
infeasible or unbounded, and a simplex basis is
available (from simplex or crossover). Note that if a
model is determined to be infeasible or unbounded when
solving with barrier, prior to crossover, then this
additional information will not be available. Note
that if a model is found to be either infeasible or
unbounded, and you simply want to know which one it
is, you should use the DualReductions parameter
instead. It performs much less additional computation.
Note: Only affects linear programming (LP) models
-IntFeasTol INTFEASTOL, --IntFeasTol INTFEASTOL
[env var: INTFEASTOL] (default: 1e-05) (type: float):
An integrality restriction on a variable is considered
satisfied when the variable’s value is less than
IntFeasTol from the nearest integer value. Tightening
this tolerance can produce smaller integrality
violations, but very tight tolerances may
significantly increase runtime. Loosening this
tolerance rarely reduces runtime. Note: Only affects
mixed integer programming (MIP) models
-IntegralityFocus INTEGRALITYFOCUS, --IntegralityFocus INTEGRALITYFOCUS
[env var: INTEGRALITYFOCUS] (default: 0) (type: int):
One unfortunate reality in MIP is that integer
variables don’t always take exact integral values.
While this typically doesn’t create significant
problems, in some situations the side-effects can be
quite undesirable. The best-known example is probably
a *trickle flow*, where a continuous variable that is
meant to be zero when an associated binary variable is
zero instead takes a non-trivial value. More
precisely, given a constraint y \leq M b, where y is a
non- negative continuous variable, b is a binary
variable, and M is a constant that captures the
largest possible value of y, the constraint is
intended to enforce the relationship that y must be
zero if b is zero. With the default integer
feasibility tolerance, the binary variable is allowed
to take a value as large as 1e-5 while still being
considered as taking value zero. If the M value is
large, then the M b upper bound on the y variable can
be substantial. Reducing the value of the IntFeasTol
parameter can mitigate the effects of such trickle
flows, but often at a significant cost, and often with
limited success. The IntegralityFocus parameter
provides a better alternative. Setting this parameter
to 1 requests that the solver work harder to try to
avoid solutions that exploit integrality tolerances.
More precisely, the solver tries to find solutions
that are still (nearly) feasible if all integer
variables are rounded to exact integral values. We
should say that the solver won’t always succeed in
finding such solutions, and that this setting
introduces a modest performance penalty, but the
setting will significantly reduce the frequency and
magnitude of such violations.
-IterationLimit ITERATIONLIMIT, --IterationLimit ITERATIONLIMIT
[env var: ITERATIONLIMIT] (default: 1e+100) (type:
float): Limits the number of simplex iterations
performed. The limit applies to MIP, barrier
crossover, and simplex. Optimization returns with an
ITERATION_LIMIT status if the limit is exceeded.
-JSONSolDetail JSONSOLDETAIL, --JSONSolDetail JSONSOLDETAIL
[env var: JSONSOLDETAIL] (default: 0) (type: int):
This parameter controls the amount of detail included
in a JSON solution. For example, when this parameter
is set to 1, the JSON string will contain data for all
of the variables, even those with solution value 0.
For a precise description of the contents of the
resulting JSON string, please refer to the JSON
solution format section.
-JobID JOBID, --JobID JOBID
[env var: JOBID] (default: ) (type: str): If you are
running on a Compute Server, this parameter provides
the Compute Server Job ID for the current job. Note
that this is a read- only parameter.
-LPWarmStart LPWARMSTART, --LPWarmStart LPWARMSTART
[env var: LPWARMSTART] (default: 1) (type: int):
Controls whether and how Gurobi uses warm start
information for an LP optimization. The non default
setting of 2 is particularly useful for communicating
advanced start information while retaining the
performance benefits of presolve. A warm start can
consist of any combination of basis statuses, a primal
start vector, or a dual start vector. It is specified
using the attributes VBasis and CBasis or PStart and
DStart on the original model. As a general rule,
setting this parameter to 0 ignores any start
information and solves the model from scratch. Setting
it to 1 (the default) uses the provided warm start
information to solve the original, unpresolved
problem, regardless of whether presolve is enabled.
Setting it to 2 uses the start information to solve
the presolved problem, assuming that presolve is
enabled. This involves mapping the solution of the
original problem into an equivalent (or sometimes
nearly equivalent) crushed solution of the presolved
problem. If presolve is disabled, then setting 2 still
prioritizes start vectors, while setting 1 prioritizes
basis statuses. Taken together, the LPWarmStart
parameter setting, the LP algorithm specified by
Gurobi’s Method parameter, and the available advanced
start information determine whether Gurobi will use
basis statuses only, basis statuses augmented with
information from start vectors, or a basis obtained by
applying the crossover method to the provided primal
and dual start vectors to jump start the optimization.
When Gurobi’s Method parameter requests the barrier
solver, primal and dual start vectors are prioritized
over basis statuses (but only if you provide both).
These start vectors are fed to the crossover
procedure. This is the same crossover that is used to
compute a basic solution from the interior solution
produced by the core barrier algorithm, but in this
case crossover is started from arbitrary start
vectors. If you set the LPWarmStart parameter to 1,
crossover will be invoked on the original model using
the provided vectors. Any provided basis information
will not be used in this case. If you set LPWarmStart
to 2, crossover will be invoked on the presolved model
using crushed start vectors. If you set the parameter
to 2 and provide a basis but no start vectors, the
basis will be used to compute the corresponding primal
and dual solutions on the original model. Those
solutions will then be crushed and used as primal and
dual start vectors for the crossover, which will then
construct a basis for the presolved model. Note that
for all of these settings and start combinations, no
barrier algorithm iterations are performed. The
simplex algorithms provide more warm-starting options.
With a parameter value of 1, simplex will start from a
provided basis, if available. Otherwise, it uses a
provided start vector to refine the crash basis it
computes. Primal simplex will use PStart and dual
simplex will use DStart in this refinement process.
With a value of 2, simplex will use the crushed start
vector on the presolved model (PStart for primal
simplex, DStart for dual) to refine the crash basis.
This is true regardless of whether the start is
derived from start vectors or a starting basis from
the original model. The difference is that if you
provide an advanced basis, the basis will be used to
compute the corresponding primal and dual solutions on
the original model from which the primal or dual start
on the presolved model will be derived. Note: Only
affects linear programming (LP) models
-LazyConstraints LAZYCONSTRAINTS, --LazyConstraints LAZYCONSTRAINTS
[env var: LAZYCONSTRAINTS] (default: 0) (type: int):
Programs that add lazy constraints through a callback
must set this parameter to value 1. The parameter
tells the Gurobi algorithms to avoid certain
reductions and transformations that are incompatible
with lazy constraints. Note that if you use lazy
constraints by setting the Lazy attribute (and not
through a callback), there’s no need to set this
parameter. Note: Only affects mixed integer
programming (MIP) models
-LicenseID LICENSEID, --LicenseID LICENSEID
[env var: LICENSEID] (default: 0) (type: int): When
using a WLS license, set this parameter to the license
ID. You can retrieve this value from your account on
the Gurobi Web License Manager site.
-LiftProjectCuts LIFTPROJECTCUTS, --LiftProjectCuts LIFTPROJECTCUTS
[env var: LIFTPROJECTCUTS] (default: -1) (type: int):
Controls lift-and-project cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-LogFile LOGFILE, --LogFile LOGFILE
[env var: LOGFILE] (default: ) (type: str): Determines
the name of the Gurobi log file. Modifying this
parameter closes the current log file and opens the
specified file. Use an empty string for no log file.
Use OutputFlag to shut off all logging.
-LogToConsole LOGTOCONSOLE, --LogToConsole LOGTOCONSOLE
[env var: LOGTOCONSOLE] (default: 1) (type: int):
Enables or disables console logging. Note that this
refers to the output of Gurobi to the console. This
includes the various display and print functions
provided by the API in interactive environments. Use
OutputFlag to shut off all logging.
-MIPFocus MIPFOCUS, --MIPFocus MIPFOCUS
[env var: MIPFOCUS] (default: 0) (type: int): The
MIPFocus parameter allows you to modify your high-
level solution strategy, depending on your goals. By
default, the Gurobi MIP solver strikes a balance
between finding new feasible solutions and proving
that the current solution is optimal. If you are more
interested in finding feasible solutions quickly, you
can select "MIPFocus=1". If you believe the solver is
having no trouble finding good quality solutions, and
wish to focus more attention on proving optimality,
select "MIPFocus=2". If the best objective bound is
moving very slowly (or not at all), you may want to
try "MIPFocus=3" to focus on the bound. Note: Only
affects mixed integer programming (MIP) models
-MIPGap MIPGAP, --MIPGap MIPGAP
[env var: MIPGAP] (default: 0.0001) (type: float): The
MIP solver will terminate (with an optimal result)
when the gap between the lower and upper objective
bound is less than MIPGap times the absolute value of
the incumbent objective value. More precisely, if z_P
is the primal objective bound (i.e., the incumbent
objective value, which is the upper bound for
minimization problems), and z_D is the dual objective
bound (i.e., the lower bound for minimization
problems), then the MIP gap is defined as gap = \vert
z_P - z_D\vert / \vert z_P\vert. Note that if z_P =
z_D = 0, then the gap is defined to be zero. If z_P =
0 and z_D \neq 0, the gap is defined to be infinity.
For most models, z_P and z_D will have the same sign
throughout the optimization process, and then the gap
is monotonically decreasing. But if z_P and z_D have
opposite signs, the relative gap may increase after
finding a new incumbent solution, even though the
absolute gap \vert z_P - z_D\vert has decreased. Note:
Only affects mixed integer programming (MIP) models
-MIPGapAbs MIPGAPABS, --MIPGapAbs MIPGAPABS
[env var: MIPGAPABS] (default: 1e-10) (type: float):
The MIP solver will terminate (with an optimal result)
when the gap between the lower and upper objective
bound is less than MIPGapAbs. Note: Only affects mixed
integer programming (MIP) models
-MIPSepCuts MIPSEPCUTS, --MIPSepCuts MIPSEPCUTS
[env var: MIPSEPCUTS] (default: -1) (type: int):
Controls MIP separation cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-MIQCPMethod MIQCPMETHOD, --MIQCPMethod MIQCPMETHOD
[env var: MIQCPMETHOD] (default: -1) (type: int):
Controls the method used to solve MIQCP models. Value
1 uses a linearized, outer-approximation approach,
while value 0 solves continuous QCP relaxations at
each node. The default setting (-1) chooses
automatically. Note: Only affects MIQCP models
-MIRCuts MIRCUTS, --MIRCuts MIRCUTS
[env var: MIRCUTS] (default: -1) (type: int): Controls
Mixed Integer Rounding (MIR) cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-MarkowitzTol MARKOWITZTOL, --MarkowitzTol MARKOWITZTOL
[env var: MARKOWITZTOL] (default: 0.0078125) (type:
float): The Markowitz tolerance is used to limit
numerical error in the simplex algorithm.
Specifically, larger values reduce the error
introduced in the simplex basis factorization. A
larger value may avoid numerical problems in rare
situations, but it will also harm performance.
-MemLimit MEMLIMIT, --MemLimit MEMLIMIT
[env var: MEMLIMIT] (default: 1e+100) (type: float):
Limits the total amount of memory (in GB, i.e., 10^9
bytes) available to Gurobi. If more is needed, Gurobi
will fail with an OUT_OF_MEMORY error. Note that it is
not possible to retrieve solution information after an
error termination. Thus, the behavior of this
parameter is different from that of other termination
criteria like SoftMemLimit, TimeLimit, or NodeLimit,
where the solver will terminate with a Status Code and
solution information will still be available. One
advantage of using this parameter rather than the
similar SoftMemLimit is that MemLimit is checked after
every memory allocation, so Gurobi will terminate at
precisely the point where the limit is exceeded. Note
that allocated memory is tracked across all models
within a Gurobi environment. If you create multiple
models in one environment, these additional models
will count towards overall memory consumption. Memory
usage is also tracked across all threads. One
consequence of this is that termination may be non-
deterministic for multi-threaded runs.
-Method METHOD, --Method METHOD
[env var: METHOD] (default: -1) (type: int): Algorithm
used to solve continuous models or the initial root
relaxation of a MIP model. Options are: *
-1=automatic, * 0=primal simplex, * 1=dual simplex, *
2=barrier, * 3=concurrent, * 4=deterministic
concurrent, and * 5=deterministic concurrent simplex
(deprecated; see ConcurrentMethod). Available settings
and default behaviour depend on the model type or the
type of the initial root relaxation. In the current
release, the default Automatic ("Method=-1") setting
will typically choose non- deterministic concurrent
("Method=3") for an LP, barrier ("Method=2") for a QP
or QCP, and dual ("Method=1") for the MIP root
relaxation. If the size of the MIP root relaxation is
large, then it will often select deterministic
concurrent ("Method=4") or deterministic concurrent
simplex ("Method=5"). Concurrent methods aren’t
available for QP and QCP. Only the simplex and barrier
algorithms are available for continuous QP models. If
you select barrier ("Method=2") to solve the root of
an MIQP model, then you need to also select barrier
for the node relaxations (i.e. set NodeMethod=2). Only
barrier is available for continuous QCP models.
However if you choose LP relaxations for solving
MIQCP, you can also select the simplex algorithms
("Method=0" or "Method=1"). Concurrent optimizers run
multiple solvers on multiple threads simultaneously
and choose the one that finishes first. The solvers
that are run concurrently can be controlled with the
ConcurrentMethod parameter. The deterministic options
("Method=4" and "Method=5") give the exact same result
each time, while the non-deterministic option
("Method=3") is often faster but can produce different
optimal bases when run multiple times. The default
setting is rarely significantly slower than the best
possible setting, so you generally won’t see a big
gain from changing this parameter. There are classes
of models where one particular algorithm is
consistently fastest, though, so you may want to
experiment with different options when confronted with
a particularly difficult model. Note that if memory is
tight on an LP model, you should consider using the
dual simplex method ("Method=1"). The concurrent
optimizer, which is typically chosen when using the
default setting, consumes a lot more memory than dual
simplex alone. In multiobjective LP optimization: *
The first objective is solved using LP defaults. It
can be set by the user using the "Method" parameter. *
Subsequent objectives are solved by default using
primal simplex to allow for warm starting. The
algorithm used here can be controlled using
MultiObjMethod.
-MinRelNodes MINRELNODES, --MinRelNodes MINRELNODES
[env var: MINRELNODES] (default: -1) (type: int):
Number of nodes to explore in the minimum relaxation
heuristic. This heuristic is quite expensive, and
generally produces poor quality solutions. You should
generally only use it if other means, including
exploration of the tree with default settings, fail to
produce a feasible solution. The default value
automatically chooses whether to apply the heuristic.
It will only rarely choose to do so. Note: Only
affects mixed integer programming (MIP) models
-MixingCuts MIXINGCUTS, --MixingCuts MIXINGCUTS
[env var: MIXINGCUTS] (default: -1) (type: int):
Controls Mixing cut generation. Use 0 to disable these
cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-ModKCuts MODKCUTS, --ModKCuts MODKCUTS
[env var: MODKCUTS] (default: -1) (type: int):
Controls mod-k cut generation. Use 0 to disable these
cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-MultiObjMethod MULTIOBJMETHOD, --MultiObjMethod MULTIOBJMETHOD
[env var: MULTIOBJMETHOD] (default: -1) (type: int):
When solving a continuous multi-objective model using
a hierarchical approach, the model is solved once for
each objective. The algorithm used to solve for the
highest priority objective is controlled by the Method
parameter. This parameter determines the algorithm
used to solve for subsequent objectives. As with the
Method parameters, values of 0 and 1 use primal and
dual simplex, respectively. A value of 2 indicates
that warm-start information from previous solves
should be discarded, and the model should be solved
from scratch (using the algorithm indicated by the
Method parameter). The default setting of -1 usually
chooses primal simplex. Note: Only affects continuous
multi-objective models
-MultiObjPre MULTIOBJPRE, --MultiObjPre MULTIOBJPRE
[env var: MULTIOBJPRE] (default: -1) (type: int):
Controls the initial presolve level used for multi-
objective models. Value 0 disables the initial
presolve, value 1 applies presolve conservatively, and
value 2 applies presolve aggressively. The default -1
value usually applies presolve conservatively.
Aggressive presolve may increase the chance of the
objective values being slightly different than those
for other options. Note: Only affects multi-objective
models
-NLPHeur NLPHEUR, --NLPHeur NLPHEUR
[env var: NLPHEUR] (default: 1) (type: int): The NLP
heuristic uses a non-linear barrier solver to find
feasible solutions to non-convex quadratic models. It
can often find solutions much more quickly than the
alternative, but in some cases it can consume
significant runtime without producing a solution. By
default, the heuristic is enabled (1). Use 0 to
disable the heuristic. Note: Only affects models with
nonconvex quadratic expressions in the objective or
constraints
-NetworkAlg NETWORKALG, --NetworkAlg NETWORKALG
[env var: NETWORKALG] (default: -1) (type: int):
Controls whether to use network simplex. Value 0
doesn’t use network simplex. Value 1 indicates to use
network simplex, if an LP is a network problem. The
default -1 value chooses automatically. Note: Only
affects linear programming (LP) models
-NetworkCuts NETWORKCUTS, --NetworkCuts NETWORKCUTS
[env var: NETWORKCUTS] (default: -1) (type: int):
Controls network cut generation. Use 0 to disable
these cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-NoRelHeurTime NORELHEURTIME, --NoRelHeurTime NORELHEURTIME
[env var: NORELHEURTIME] (default: 0.0) (type: float):
Limits the amount of time (in seconds) spent in the
NoRel heuristic. This heuristic searches for high-
quality feasible solutions before solving the root
relaxation. It can be quite useful on models where the
root relaxation is particularly expensive. Note that
this parameter will introduce non-determinism -
different runs may take different paths. Use the
NoRelHeurWork parameter for deterministic results.
Note: Only affects mixed integer programming (MIP)
models
-NoRelHeurWork NORELHEURWORK, --NoRelHeurWork NORELHEURWORK
[env var: NORELHEURWORK] (default: 0.0) (type: float):
Limits the amount of work spent in the NoRel
heuristic. This heuristic searches for high-quality
feasible solutions before solving the root relaxation.
It can be quite useful on models where the root
relaxation is particularly expensive. The work metric
used in this parameter is tough to define precisely. A
single unit corresponds to roughly a second, but this
will depend on the machine, the core count, and in
some cases the model. You may need to experiment to
find a good setting for your model. Note: Only affects
mixed integer programming (MIP) models
-NodeLimit NODELIMIT, --NodeLimit NODELIMIT
[env var: NODELIMIT] (default: 1e+100) (type: float):
Limits the number of MIP nodes explored. Optimization
returns with an NODE_LIMIT status if the limit is
exceeded. Note that if multiple threads are used for
the optimization, the actual number of explored nodes
may be slightly larger than the set limit. This
parameter is callback settable. It can be changed from
within a callback when the "where" value is
"PRESOLVED", "SIMPLEX", "MIP", "MIPSOL", "MIPNODE",
"BARRIER", or "MULTIOBJ" (see the Callback Codes
section for more information). How to do that for the
different APIs is illustrated here. In case of a
remote server, the change of a parameter from within a
callback may not be taken into account immediately.
Note: Only affects mixed integer programming (MIP)
models
-NodeMethod NODEMETHOD, --NodeMethod NODEMETHOD
[env var: NODEMETHOD] (default: -1) (type: int):
Algorithm used for MIP node relaxations (except for
the initial root node relaxation, see Method). Options
are: -1=automatic, 0=primal simplex, 1=dual simplex,
and 2=barrier. Note that barrier is not an option for
MIQP node relaxations. Note: Only affects mixed
integer programming (MIP) models
-NodefileDir NODEFILEDIR, --NodefileDir NODEFILEDIR
[env var: NODEFILEDIR] (default: .) (type: str):
Determines the directory into which nodes are written
when node memory usage exceeds the specified
NodefileStart value. Note: Only affects mixed integer
programming (MIP) models
-NodefileStart NODEFILESTART, --NodefileStart NODEFILESTART
[env var: NODEFILESTART] (default: 1e+100) (type:
float): If you find that the Gurobi Optimizer exhausts
memory when solving a MIP, you should modify the
"NodefileStart" parameter. When the amount of memory
used to store nodes (measured in GB, i.e., 10^9 bytes)
exceeds the specified parameter value, nodes are
compressed and written to disk. We recommend a setting
of "0.5", but you may wish to choose a different
value, depending on the memory available in your
machine. By default, nodes are written to the current
working directory. The NodefileDir parameter can be
used to choose a different location. If you still
exhaust memory after setting the "NodefileStart"
parameter to a small value, you should try limiting
the thread count. Each thread in parallel MIP requires
a copy of the model, as well as several other large
data structures. Reducing the Threads parameter can
sometimes significantly reduce memory usage. Note:
Only affects mixed integer programming (MIP) models
-NonConvex NONCONVEX, --NonConvex NONCONVEX
[env var: NONCONVEX] (default: -1) (type: int): Sets
the strategy for handling non-convex quadratic
objectives or non- convex quadratic constraints. With
setting 0, an error is reported if the original user
model contains non-convex quadratic constructs (unless
Q matrix linearization, as controlled by the
PreQLinearize parameter, removes the non-convexity).
With setting 1, an error is reported if non-convex
quadratic constructs could not be discarded or
linearized during presolve. With setting 2, non-convex
quadratic problems are solved by translating them into
bilinear form and applying spatial branching. The
default -1 setting is currently almost equivalent to
2, except that it takes less care to avoid presolve
reductions that might transform a convex constraint
into one that can no longer be detected to be convex,
and thus can sometimes perform more presolve
reductions. Note: Only affects QP, QCP, MIQP, and
MIQCP models
-NormAdjust NORMADJUST, --NormAdjust NORMADJUST
[env var: NORMADJUST] (default: -1) (type: int):
Chooses from among multiple pricing norm variants. The
details of how this parameter affects the simplex
pricing algorithm are subtle and difficult to
describe, so we’ve simply labeled the options 0
through 3. The default value of -1 chooses
automatically. Changing the value of this parameter
rarely produces a significant benefit.
-NumericFocus NUMERICFOCUS, --NumericFocus NUMERICFOCUS
[env var: NUMERICFOCUS] (default: 0) (type: int): The
NumericFocus parameter controls the degree to which
the code attempts to detect and manage numerical
issues. The default setting (0) makes an automatic
choice, with a slight preference for speed. Settings
1-3 increasingly shift the focus towards being more
careful in numerical computations. With higher values,
the code will spend more time checking the numerical
accuracy of intermediate results, and it will employ
more expensive techniques in order to avoid potential
numerical issues.
-OBBT OBBT, --OBBT OBBT
[env var: OBBT] (default: -1) (type: int): Value 0
disables optimality-based bound tightening (OBBT).
Levels 1-3 describe the amount of work allowed for
OBBT ranging from moderate to aggressive. The default
-1 value is an automatic setting which chooses a
rather moderate setting.
-ObjNumber OBJNUMBER, --ObjNumber OBJNUMBER
[env var: OBJNUMBER] (default: 0) (type: int): When
working with multiple objectives, this parameter
selects the index of the objective you want to work
with. When you query or modify an attribute associated
with multiple objectives (ObjN, ObjNVal, etc.), the
ObjNumber parameter will determine which objective is
actually affected. The value of this parameter should
be less than the value of the NumObj attribute (which
captures the number of objectives in the model).
Please refer to the discussion of Multiple Objectives
for more information on the use of alternative
objectives.
-ObjScale OBJSCALE, --ObjScale OBJSCALE
[env var: OBJSCALE] (default: 0.0) (type: float): When
positive, divides the model objective by the specified
value to avoid numerical issues that may result from
very large or very small objective coefficients. The
default value of 0 decides on the scaling
automatically. A value less than zero uses the maximum
coefficient to the specified power as the scaling (so
"ObjScale=-0.5" would scale by the square root of the
largest objective coefficient). Note that objective
scaling can lead to large dual violations on the
original, unscaled objective when the optimality
tolerance with the scaled objective is barely
satisfied, so it should be used sparingly. Note also
that scaling will be more effective when all objective
coefficients are of similar orders of magnitude, as
opposed to objectives with a wide range of
coefficients. In the latter case, consider using the
Multiple Objectives feature instead.
-OptimalityTol OPTIMALITYTOL, --OptimalityTol OPTIMALITYTOL
[env var: OPTIMALITYTOL] (default: 1e-06) (type:
float): For the simplex algorithm and crossover,
reduced costs must all be smaller than OptimalityTol
in the improving direction in order for a model to be
declared optimal.
-OutputFlag OUTPUTFLAG, --OutputFlag OUTPUTFLAG
[env var: OUTPUTFLAG] (default: 1) (type: int):
Enables or disables solver output. Use LogFile and
LogToConsole for finer-grain control. Setting
OutputFlag to 0 is equivalent to setting LogFile to
"""" and LogToConsole to 0. Note that server-side
logging is always active for remote jobs run on Gurobi
Instant Cloud, Compute Server, or Cluster Manager.
This is not impacted by any user parameter settings.
-PSDCuts PSDCUTS, --PSDCuts PSDCUTS
[env var: PSDCUTS] (default: -1) (type: int): Controls
PSD cut generation. Use 0 to disable these cuts, 1 for
moderate cut generation, or 2 for aggressive cut
generation. The default -1 value chooses
automatically. Overrides the Cuts parameter. Note:
Only affects models with nonconvex quadratic
expressions in the objective or constraints
-PSDTol PSDTOL, --PSDTol PSDTOL
[env var: PSDTOL] (default: 1e-06) (type: float): Sets
a limit on the amount of diagonal perturbation that
the optimizer is allowed to perform on a Q matrix in
order to correct minor PSD violations. If a larger
perturbation is required, the optimizer will terminate
with a Q_NOT_PSD error. Note: Only affects QP, QCP,
MIQP, and MIQCP models
-PartitionPlace PARTITIONPLACE, --PartitionPlace PARTITIONPLACE
[env var: PARTITIONPLACE] (default: 15) (type: int):
Setting the Partition attribute on at least one
variable in a model enables the partitioning
heuristic, which uses large-neighborhood search to try
to improve the current incumbent solution. This
parameter determines where that heuristic runs.
Options are: * Before the root relaxation is solved
(16) * At the start of the root cut loop (8) * At the
end of the root cut loop (4) * At the nodes of the
branch-and-cut search (2) * When the branch-and-cut
search terminates (1) The parameter value is a bit
vector, where each bit turns the heuristic on or off
at that place. The numerical values next to the
options listed above indicate which bit controls the
corresponding option. Thus, for example, to enable the
heuristic at the beginning and end of the root cut
loop (and nowhere else), you would set the 8 bit and
the 4 bit to 1, which would correspond to a parameter
value of 12. The default value of 15 indicates that we
enable every option except the first one listed above.
-PerturbValue PERTURBVALUE, --PerturbValue PERTURBVALUE
[env var: PERTURBVALUE] (default: 0.0002) (type:
float): Magnitude of the simplex perturbation. Note
that perturbation is only applied when progress has
stalled, so the parameter will often have no effect.
-PoolGap POOLGAP, --PoolGap POOLGAP
[env var: POOLGAP] (default: 1e+100) (type: float):
Determines how large a (relative) gap to tolerate in
stored solutions. When this parameter is set to a non-
default value, solutions whose objective values exceed
that of the best known solution by more than the
specified (relative) gap are discarded. For example,
if the MIP solver has found a solution at objective
100, then a setting of "PoolGap=0.2" would discard
solutions with objective worse than 120 (assuming a
minimization objective). Note: Only affects mixed
integer programming (MIP) models
-PoolGapAbs POOLGAPABS, --PoolGapAbs POOLGAPABS
[env var: POOLGAPABS] (default: 1e+100) (type: float):
Determines how large a (absolute) gap to tolerate in
stored solutions. When this parameter is set to a non-
default value, solutions whose objective values exceed
that of the best known solution by more than the
specified (absolute) gap are discarded. For example,
if the MIP solver has found a solution at objective
100, then a setting of "PoolGapAbs=20" would discard
solutions with objective worse than 120 (assuming a
minimization objective). Note: Only affects mixed
integer programming (MIP) models
-PoolSearchMode POOLSEARCHMODE, --PoolSearchMode POOLSEARCHMODE
[env var: POOLSEARCHMODE] (default: 0) (type: int):
Selects different modes for exploring the MIP search
tree. With the default setting ("PoolSearchMode=0"),
the MIP solver tries to find an optimal solution to
the model. It keeps other solutions found along the
way, but those are incidental. By setting this
parameter to a non- default value, the MIP search will
continue after the optimal solution has been found in
order to find additional, high-quality solutions. With
a non-default value ("PoolSearchMode=1" or
"PoolSearchMode=2"), the MIP solver will try to find
"n" solutions, where "n" is determined by the value of
the PoolSolutions parameter. With a setting of 1,
there are no guarantees about the quality of the extra
solutions, while with a setting of 2, the solver will
find the "n" best solutions. The cost of the solve
will increase with increasing values of this
parameter. Once optimization is complete, the
PoolObjBound attribute can be used to evaluate the
quality of the solutions that were found. For example,
a value of "PoolObjBound=100" indicates that there are
no other solutions with objective better 100, and thus
that any known solutions with objective better than
100 are better than any as-yet undiscovered solutions.
See Solution Pool for more information about solution
pools, including subtleties and limitations. Note:
Only affects mixed integer programming (MIP) models
-PoolSolutions POOLSOLUTIONS, --PoolSolutions POOLSOLUTIONS
[env var: POOLSOLUTIONS] (default: 10) (type: int):
Determines how many MIP solutions are stored. For the
default value of PoolSearchMode, these are just the
solutions that are found along the way in the process
of exploring the MIP search tree. For other values of
PoolSearchMode, this parameter sets a target for how
many solutions to find, so larger values will impact
performance. Note: Only affects mixed integer
programming (MIP) models
-PreCrush PRECRUSH, --PreCrush PRECRUSH
[env var: PRECRUSH] (default: 0) (type: int): Shuts
off a few reductions in order to allow presolve to
transform any constraint on the original model into an
equivalent constraint on the presolved model. You
should consider setting this parameter to 1 if you are
using callbacks to add your own cuts. A cut that
cannot be applied to the presolved model will be
silently ignored. The impact on the size of the
presolved problem is usually small.
-PreDepRow PREDEPROW, --PreDepRow PREDEPROW
[env var: PREDEPROW] (default: -1) (type: int):
Controls the presolve dependent row reduction, which
eliminates linearly dependent constraints from the
constraint matrix. The default setting (-1) applies
the reduction to continuous models but not to MIP
models. Setting 0 turns the reduction off for all
models. Setting 1 turns it on for all models.
-PreDual PREDUAL, --PreDual PREDUAL
[env var: PREDUAL] (default: -1) (type: int): Controls
whether presolve forms the dual of a continuous model.
Depending on the structure of the model, solving the
dual can reduce overall solution time. The default
setting uses a heuristic to decide. Setting 0 forbids
presolve from forming the dual, while setting 1 forces
it to take the dual. Setting 2 employs a more
expensive heuristic that forms both the presolved
primal and dual models (on two threads), and
heuristically chooses one of them. Note: Mainly
affects LP, QP, and QCP models, but it is also used
for the initial root relaxation of mixed integer
programs.
-PreMIQCPForm PREMIQCPFORM, --PreMIQCPForm PREMIQCPFORM
[env var: PREMIQCPFORM] (default: -1) (type: int):
Determines the format of the presolved version of an
MIQCP model. Option 0 leaves the model in MIQCP form,
so the branch-and-cut algorithm will operate on a
model with arbitrary quadratic constraints. Option 1
always transforms the model into MISOCP form;
quadratic constraints are transformed into second-
order cone constraints. Option 2 always transforms the
model into disaggregated MISOCP form; quadratic
constraints are transformed into rotated cone
constraints, where each rotated cone contains two
terms and involves only three variables. The default
setting (-1) choose automatically. The automatic
setting works well, but there are cases where forcing
a different form can be beneficial. Note: Only affects
MIQCP models
-PrePasses PREPASSES, --PrePasses PREPASSES
[env var: PREPASSES] (default: -1) (type: int): Limits
the number of passes performed by presolve. The
default setting (-1) chooses the number of passes
automatically. You should experiment with this
parameter when you find that presolve is consuming a
large fraction of total solve time.
-PreQLinearize PREQLINEARIZE, --PreQLinearize PREQLINEARIZE
[env var: PREQLINEARIZE] (default: -1) (type: int):
Controls presolve Q matrix linearization. Binary
variables in quadratic expressions provide some
freedom to state the same expression in multiple
different ways. Options 1 and 2 of this parameter
attempt to linearize quadratic constraints or a
quadratic objective, replacing quadratic terms with
linear terms, using additional variables and linear
constraints. This can potentially transform an MIQP or
MIQCP model into an MILP. Option 1 focuses on
producing an MILP reformulation with a strong LP
relaxation, with a goal of limiting the size of the
MIP search tree. Option 2 aims for a compact
reformulation, with a goal of reducing the cost of
each node. Option 0 attempts to leave Q matrices
unmodified; it won’t add variables or constraints, but
it may still perform adjustments on quadratic
objective functions to make them positive semi-
definite (PSD). The default setting (-1) chooses
automatically. Note: Only affects MIQP and MIQCP
models
-PreSOS1BigM PRESOS1BIGM, --PreSOS1BigM PRESOS1BIGM
[env var: PRESOS1BIGM] (default: -1.0) (type: float):
Controls the automatic reformulation of SOS1
constraints into binary form. SOS1 constraints are
often handled more efficiently using a binary
representation. The reformulation often requires
"big-M" values to be introduced as coefficients. This
parameter specifies the largest "big-M" that can be
introduced by presolve when performing this
reformulation. Larger values increase the chances that
an SOS1 constraint will be reformulated, but very
large values (e.g., 1e8) can lead to numerical issues.
The default value of -1 chooses a threshold
automatically. You should set the parameter to 0 to
shut off SOS1 reformulation entirely, or a large value
to force reformulation. Please refer to this section
for more information on SOS constraints.
-PreSOS1Encoding PRESOS1ENCODING, --PreSOS1Encoding PRESOS1ENCODING
[env var: PRESOS1ENCODING] (default: -1) (type: int):
Controls the automatic reformulation of SOS1
constraints. Such constraints can be handled directly
by the MIP branch-and-cut algorithm, but they are
often handled more efficiently by reformulating them
using binary or integer variables. There are several
diffent ways to perform this reformulation; they
differ in their size and strength. Smaller
reformulations add fewer variables and constraints to
the model. Stronger reformulations reduce the number
of branch-and-cut nodes required to solve the
resulting model. Options 0 and 1 of this parameter
encode an SOS1 constraint using a formulation whose
size is linear in the number of SOS members. Option 0
uses a so-called multiple choice model. It usually
produces an LP relaxation that is easier to solve.
Option 1 uses an incremental model. It often gives a
stronger representation, reducing the amount of
branching required to solve harder problems. Options 2
and 3 of this parameter encode the SOS1 using a
formulation of logarithmic size. They both only apply
when all the variables in the SOS1 are non-negative.
Option 3 additionally requires that the sum of the
variables in the SOS1 is equal to 1. Logarithmic
formulations are often advantageous when the SOS1
constraint has a large number of members. Option 2
focuses on a formulation whose LP relaxation is easier
to solve, while option 3 has better branching
behavior. The default value of -1 chooses a
reformulation for each SOS1 constraint automatically.
Note that the reformulation of SOS1 constraints is
also influenced by the PreSOS1BigM parameter. To shut
off the reformulation entirely you should set that
parameter to 0. Please refer to this section for more
information on SOS constraints.
-PreSOS2BigM PRESOS2BIGM, --PreSOS2BigM PRESOS2BIGM
[env var: PRESOS2BIGM] (default: -1.0) (type: float):
Controls the automatic reformulation of SOS2
constraints into binary form. SOS2 constraints are
often handled more efficiently using a binary
representation. The reformulation often requires
"big-M" values to be introduced as coefficients. This
parameter specifies the largest "big-M" that can be
introduced by presolve when performing this
reformulation. Larger values increase the chances that
an SOS2 constraint will be reformulated, but very
large values (e.g., 1e8) can lead to numerical issues.
The default value of -1 chooses a threshold
automatically. You should set the parameter to 0 to
shut off SOS2 reformulation entirely, or a large value
to force reformulation. Please refer to this section
for more information on SOS constraints.
-PreSOS2Encoding PRESOS2ENCODING, --PreSOS2Encoding PRESOS2ENCODING
[env var: PRESOS2ENCODING] (default: -1) (type: int):
Controls the automatic reformulation of SOS2
constraints. Such constraints can be handled directly
by the MIP branch-and-cut algorithm, but they are
often handled more efficiently by reformulating them
using binary or integer variables. There are several
diffent ways to perform this reformulation; they
differ in their size and strength. Smaller
reformulations add fewer variables and constraints to
the model. Stronger reformulations reduce the number
of branch-and-cut nodes required to solve the
resulting model. Options 0 and 1 of this parameter
encode an SOS2 constraint using a formulation whose
size is linear in the number of SOS members. Option 0
uses a so-called multiple choice model. It usually
produces an LP relaxation that is easier to solve.
Option 1 uses an incremental model. It often gives a
stronger representation, reducing the amount of
branching required to solve harder problems. Options 2
and 3 of this parameter encode the SOS2 using a
formulation of logarithmic size. They both only apply
when all the variables in the SOS2 are non-negative.
Option 3 additionally requires that the sum of the
variables in the SOS2 is equal to 1. Logarithmic
formulations are often advantageous when the SOS2
constraint has a large number of members. Option 2
focuses on a formulation whose LP relaxation is easier
to solve, while option 3 has better branching
behavior. The default value of -1 chooses a
reformulation for each SOS2 constraint automatically.
Note that the reformulation of SOS2 constraints is
also influenced by the PreSOS2BigM parameter. To shut
off the reformulation entirely you should set that
parameter to 0. Please refer to this section for more
information on SOS constraints.
-PreSparsify PRESPARSIFY, --PreSparsify PRESPARSIFY
[env var: PRESPARSIFY] (default: -1) (type: int):
Controls the presolve sparsify reduction. This
reduction can sometimes significantly reduce the
number of non-zero values in the presolved model.
Value 0 shuts off the reduction, while value 1 forces
it on for mixed integer programming (MIP) models and
value 2 forces it on for all types of models,
including linear programming (LP) models, and MIP
relaxations. The default value of -1 chooses
automatically.
-Presolve PRESOLVE, --Presolve PRESOLVE
[env var: PRESOLVE] (default: -1) (type: int):
Controls the presolve level. A value of -1 corresponds
to an automatic setting. Other options are off (0),
conservative (1), or aggressive (2). More aggressive
application of presolve takes more time, but can
sometimes lead to a significantly tighter model.
-ProjImpliedCuts PROJIMPLIEDCUTS, --ProjImpliedCuts PROJIMPLIEDCUTS
[env var: PROJIMPLIEDCUTS] (default: -1) (type: int):
Controls projected implied bound cut generation. Use 0
to disable these cuts, 1 for moderate cut generation,
or 2 for aggressive cut generation. The default -1
value chooses automatically. Overrides the Cuts
parameter. Note: Only affects mixed integer
programming (MIP) models
-PumpPasses PUMPPASSES, --PumpPasses PUMPPASSES
[env var: PUMPPASSES] (default: -1) (type: int):
Number of passes of the feasibility pump heuristic.
This heuristic is quite expensive, and generally
produces poor quality solutions. You should generally
only use it if other means, including exploration of
the tree with default settings, fail to produce a
feasible solution. This parameter is callback
settable. It can be changed from within a callback
when the "where" value is "PRESOLVED", "SIMPLEX",
"MIP", "MIPSOL", "MIPNODE", "BARRIER", or "MULTIOBJ"
(see the Callback Codes section for more information).
How to do that for the different APIs is illustrated
here. In case of a remote server, the change of a
parameter from within a callback may not be taken into
account immediately. Note: Only affects mixed integer
programming (MIP) models
-QCPDual QCPDUAL, --QCPDual QCPDUAL
[env var: QCPDUAL] (default: 0) (type: int):
Determines whether dual variable values are computed
for QCP models. Computing them can add significant
time to the optimization, so you should only set this
parameter to 1 if you need them.
-Quad QUAD, --Quad QUAD
[env var: QUAD] (default: -1) (type: int): Enables or
disables quad precision computation in simplex. The -1
default setting allows the algorithm to decide. Quad
precision can sometimes help solve numerically
challenging models, but it can also significantly
increase runtime. Quad precision is only available on
processors that support quadruple precision, e.g.,
common Intel processors. On other processors, the
parameter has no effect.
-RINS RINS, --RINS RINS
[env var: RINS] (default: -1) (type: int): Frequency
of the RINS heuristic. Default value (-1) chooses
automatically. A value of 0 shuts off RINS. A positive
value "n" applies RINS at every "n-th" node of the MIP
search tree. Increasing the frequency of the RINS
heuristic shifts the focus of the MIP search away from
proving optimality, and towards finding good feasible
solutions. We recommend that you try MIPFocus,
ImproveStartGap, or ImproveStartTime before
experimenting with this parameter. Note: Only affects
mixed integer programming (MIP) models
-RLTCuts RLTCUTS, --RLTCuts RLTCUTS
[env var: RLTCUTS] (default: -1) (type: int): Controls
Relaxation Linearization Technique (RLT) cut
generation. Use 0 to disable these cuts, 1 for
moderate cut generation, or 2 for aggressive cut
generation. The default -1 value chooses
automatically. Overrides the Cuts parameter. Note:
Only affects mixed integer programming (MIP) models
-Record RECORD, --Record RECORD
[env var: RECORD] (default: 0) (type: int): Enables
API call recording. When enabled, Gurobi will write
one or more files (named "gurobi000.grbr" or similar)
that capture the sequence of Gurobi commands that your
program issued. This file can subsequently be replayed
using the Gurobi command-line tool. Replaying the file
will repeat the exact same sequence of commands, and
when completed will show the time spent in Gurobi API
routines, the time spent in Gurobi algorithms, and
will indicate whether any Gurobi environments or
models were leaked by your program. Replay files are
particularly useful in tech support situations. They
provide an easy way to relay to Gurobi tech support
the exact sequence of Gurobi commands that led to a
question or issue. This parameter must be set before
starting an empty environment (or in a "gurobi.env"
file). All Gurobi commands will be recorded until the
environment is freed or the program ends.
-RelaxLiftCuts RELAXLIFTCUTS, --RelaxLiftCuts RELAXLIFTCUTS
[env var: RELAXLIFTCUTS] (default: -1) (type: int):
Controls relax-and-lift cut generation. Use 0 to
disable these cuts, 1 for moderate cut generation, or
2 for aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-ResultFile RESULTFILE, --ResultFile RESULTFILE
[env var: RESULTFILE] (default: ) (type: str):
Specifies the name of the result file to be written
upon completion of optimization. The type of the
result file is determined by the file suffix. The most
commonly used suffixes are ".sol" (to capture the
solution vector), ".bas" (to capture the simplex
basis), and ".mst" (to capture the solution vector on
the integer variables). You can also write a ".ilp"
file (to capture the IIS for an infeasible model), or
a ".mps", ".rew", ".lp", or ".rlp" file (to capture
the original model), or a ".dua" or ".dlp" file (to
capture the dual of a pure LP model). The file suffix
may optionally be followed by ".zip", ".gz", ".bz2",
".7z" or ".xz", which produces a compressed result.
More information on the file formats can be found in
the File Format section.
-ScaleFlag SCALEFLAG, --ScaleFlag SCALEFLAG
[env var: SCALEFLAG] (default: -1) (type: int):
Controls model scaling. By default, the rows and
columns of the model are scaled in order to improve
the numerical properties of the constraint matrix. The
scaling is removed before the final solution is
returned. Scaling typically reduces solution times,
but it may lead to larger constraint violations in the
original, unscaled model. Turning off scaling
("ScaleFlag=0") can sometimes produce smaller
constraint violations. Choosing a different scaling
option can sometimes improve performance for
particularly numerically difficult models. Using
geometric mean scaling ("ScaleFlag=2") is especially
well suited for models with a wide range of
coefficients in the constraint matrix rows or columns.
Settings 1 and 3 are not as directly connected to any
specific model characteristics, so experimentation
with both settings may be needed to assess performance
impact.
-ScenarioNumber SCENARIONUMBER, --ScenarioNumber SCENARIONUMBER
[env var: SCENARIONUMBER] (default: 0) (type: int):
When working with multiple scenarios, this parameter
selects the index of the scenario you want to work
with. When you query or modify an attribute associated
with multiple scenarios (ScenNLB, ScenNUB, ScenNObj,
ScenNRHS, etc.), the ScenarioNumber parameter will
determine which scenario is actually affected. The
value of this parameter should be less than the value
of the NumScenarios attribute (which captures the
number of scenarios in the model). Please refer to the
discussion of Multiple Scenarios for more information
on the use of alternative scenarios.
-Seed SEED, --Seed SEED
[env var: SEED] (default: 0) (type: int): Modifies the
random number seed. This acts as a small perturbation
to the solver, and typically leads to different
solution paths.
-ServerPassword SERVERPASSWORD, --ServerPassword SERVERPASSWORD
[env var: SERVERPASSWORD] (default: ) (type: str): The
password for connecting to the server (either a
Compute Server or a token server). For connecting to
the Remote Services cluster referred to by the
ComputeServer parameter, you’ll need to supply the
client password. Refer to the *Gurobi Remote Services
Reference Manual* for more information on starting
Compute Server jobs. Supply the token server password
(if needed) when connecting to the server referred to
by the TokenServer parameter, You must set this
parameter through either a "gurobi.lic" file (using
"PASSWORD=pwd") or an empty environment. Changing the
parameter after your environment has been created will
have no effect.
-ServerTimeout SERVERTIMEOUT, --ServerTimeout SERVERTIMEOUT
[env var: SERVERTIMEOUT] (default: 60) (type: int):
Network time-out for Compute Server and token server
(in seconds). If the client program is unable to
contact the server for more than the specified amount
of time, the client will quit with a network error.
Refer to the *Gurobi Remote Services Reference Manual*
for more information on starting Compute Server jobs.
You must set this parameter using an empty
environment. Changing the parameter after your
environment has been created will have no effect.
-SiftMethod SIFTMETHOD, --SiftMethod SIFTMETHOD
[env var: SIFTMETHOD] (default: -1) (type: int): LP
method used to solve sifting sub-problems. Options are
Automatic (-1), Primal Simplex (0), Dual Simplex (1),
and Barrier (2). Note that this parameter only has an
effect when you are using dual simplex and sifting has
been selected (either automatically by dual simplex,
or through the Sifting parameter). Changing the value
of this parameter rarely produces a significant
benefit.
-Sifting SIFTING, --Sifting SIFTING
[env var: SIFTING] (default: -1) (type: int): Enables
or disables sifting within dual simplex. Sifting can
be useful for LP models where the number of variables
is many times larger than the number of constraints
(we typically only see significant benefits when the
ratio is 100 or more). Options are Automatic (-1), Off
(0), Moderate (1), and Aggressive (2). With a Moderate
setting, sifting will be applied to LP models and to
the initial root relaxation for MIP models. With an
Aggressive setting, sifting will be applied any time
dual simplex is used, including at the nodes of a MIP.
Note that this parameter has no effect if you aren’t
using dual simplex. Note also that Gurobi will ignore
this parameter in cases where sifting is obviously a
worse choice than dual simplex.
-SimplexPricing SIMPLEXPRICING, --SimplexPricing SIMPLEXPRICING
[env var: SIMPLEXPRICING] (default: -1) (type: int):
Determines the simplex variable pricing strategy.
Available options are Automatic (-1), Partial Pricing
(0), Steepest Edge (1), Devex (2), and Quick-Start
Steepest Edge (3). Changing the value of this
parameter rarely produces a significant benefit.
-SoftMemLimit SOFTMEMLIMIT, --SoftMemLimit SOFTMEMLIMIT
[env var: SOFTMEMLIMIT] (default: 1e+100) (type:
float): Limits the total amount of memory (in GB,
i.e., 10^9 bytes) available to Gurobi. If more is
needed, Gurobi will terminate with a MEM_LIMIT status
code. In contrast to the MemLimit parameter, the
SoftMemLimit parameter leads to a graceful exit of the
optimization, such that it is possible to retrieve
solution information afterwards or (in the case of a
MIP solve) resume the optimization. A disadvantage
compared to MemLimit is that the SoftMemLimit is only
checked at places where optimization can be terminated
gracefully, so memory use may exceed the limit between
these checks. Note that allocated memory is tracked
across all models within a Gurobi environment. If you
create multiple models in one environment, these
additional models will count towards overall memory
consumption. Memory usage is also tracked across all
threads. One consequence of this is that termination
may be non-deterministic for multi-threaded runs.
-SolFiles SOLFILES, --SolFiles SOLFILES
[env var: SOLFILES] (default: ) (type: str): During
the MIP solution process, multiple incumbent solutions
are typically found on the path to finding a proven
optimal solution. Setting this parameter to a non-
empty string causes these solutions to be written to
files (in .sol format) as they are found. The MIP
solver will append "_n.sol" to the value of the
parameter to form the name of the file that contains
solution number n. For example, setting the parameter
to value "solutions/mymodel" will create files
"mymodel_0.sol", "mymodel_1.sol", etc., in directory
"solutions". Note that intermediate solutions can be
retrieved as they are generated through a callback (by
requesting the "MIPSOL_SOL" in a "MIPSOL" callback).
This parameter makes the process simpler. Note: Only
affects mixed integer programming (MIP) models
-SolutionLimit SOLUTIONLIMIT, --SolutionLimit SOLUTIONLIMIT
[env var: SOLUTIONLIMIT] (default: 2000000000) (type:
int): Limits the number of feasible MIP solutions
found. Optimization returns with a SOLUTION_LIMIT
status once the limit has been reached. To find a
feasible solution quickly, Gurobi executes additional
feasible point heuristics when the solution limit is
set to exactly 1. Note: Only affects mixed integer
programming (MIP) models
-SolutionNumber SOLUTIONNUMBER, --SolutionNumber SOLUTIONNUMBER
[env var: SOLUTIONNUMBER] (default: 0) (type: int):
When querying attribute Xn, ObjNVal, or PoolObjVal to
retrieve an alternate MIP solution, this parameter
determines which alternate solution is retrieved. The
value of this parameter should be less than the value
of the SolCount attribute. Note: Only affects mixed
integer programming (MIP) models
-SolutionTarget SOLUTIONTARGET, --SolutionTarget SOLUTIONTARGET
[env var: SOLUTIONTARGET] (default: -1) (type: int):
Specifies the solution target for linear programs
(LP). Options are Automatic (-1), primal and dual
optimal, and basic (0), primal and dual optimal (1).
-StartNodeLimit STARTNODELIMIT, --StartNodeLimit STARTNODELIMIT
[env var: STARTNODELIMIT] (default: -1) (type: int):
This parameter limits the number of branch-and-bound
nodes explored when completing a partial MIP start.
The default value of -1 uses the value of the
SubMIPNodes parameter. A value of -2 means to only
check full MIP starts for feasibility and to ignore
partial MIP starts. A value of -3 shuts off MIP start
processing entirely. Non-negative values are node
limits. Note: Only affects mixed integer programming
(MIP) models
-StartNumber STARTNUMBER, --StartNumber STARTNUMBER
[env var: STARTNUMBER] (default: 0) (type: int): This
parameter selects the index of the MIP start you want
to work with. When you modify a MIP start value (using
the Start attribute) the StartNumber parameter will
determine which MIP start is actually affected. The
value of this parameter should be less than the value
of the NumStart attribute (which captures the number
of MIP starts in the model). The special value -1 is
meant to append new MIP start to a model, but querying
a MIP start when StartNumber is -1 will result in an
error. Note: Only affects mixed integer programming
(MIP) models
-StrongCGCuts STRONGCGCUTS, --StrongCGCuts STRONGCGCUTS
[env var: STRONGCGCUTS] (default: -1) (type: int):
Controls Strong Chvátal-Gomory (Strong-CG) cut
generation. Use 0 to disable these cuts, 1 for
moderate cut generation, or 2 for aggressive cut
generation. The default -1 value chooses
automatically. Overrides the Cuts parameter. Note:
Only affects mixed integer programming (MIP) models
-SubMIPCuts SUBMIPCUTS, --SubMIPCuts SUBMIPCUTS
[env var: SUBMIPCUTS] (default: -1) (type: int):
Controls sub-MIP cut generation. Use 0 to disable
these cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-SubMIPNodes SUBMIPNODES, --SubMIPNodes SUBMIPNODES
[env var: SUBMIPNODES] (default: 500) (type: int):
Limits the number of nodes explored by MIP-based
heuristics (such as RINS). Exploring more nodes can
produce better solutions, but it generally takes
longer. Note: Only affects mixed integer programming
(MIP) models
-Symmetry SYMMETRY, --Symmetry SYMMETRY
[env var: SYMMETRY] (default: -1) (type: int):
Controls symmetry detection. A value of -1 corresponds
to an automatic setting. Other options are off (0),
conservative (1), or aggressive (2). Symmetry can
impact a number of different parts of the algorithm,
including presolve, the MIP tree search, and the LP
solution process. Default settings are quite
effective, so changing the value of this parameter
rarely produces a significant benefit.
-TSPort TSPORT, --TSPort TSPORT
[env var: TSPORT] (default: 41954) (type: int): Port
to use when connecting to the Gurobi token server. You
should only change this if your network administrator
tells you to.
-ThreadLimit THREADLIMIT, --ThreadLimit THREADLIMIT
[env var: THREADLIMIT] (default: 0) (type: int): The
ThreadLimit parameter is a configuration parameter for
an environment which can be used to limit the number
of threads used. This limit is enforced for all
optimization calls based on this environment. The
default value of 0 implies no limit. If a thread limit
is set, trying to set the Threads parameter above this
limit will display a warning and not change the value
of the parameter. You must set the ThreadLimit
parameter through either a "gurobi.env" file (using
"ThreadLimit=limit") or an empty environment. Changing
the parameter after the environment has been created
will result in an error.
-Threads THREADS, --Threads THREADS
[env var: THREADS] (default: 0) (type: int): Controls
the number of threads to apply to parallel algorithms
(concurrent LP, parallel barrier, parallel MIP, etc.).
The default value of 0 is an automatic setting. It
will generally use as many threads as there are
virtual processors. The number of virtual processors
may exceed the number of cores due to hyperthreading
or other similar hardware features. While you will
generally get the best performance by using all
available cores in your machine, there are a few
exceptions. One is of course when you are sharing a
machine with other jobs. In this case, you should
select a thread count that doesn’t oversubscribe the
machine. We have also found that certain classes of
MIP models benefit from reducing the thread count,
often all the way down to one thread. Starting
multiple threads introduces contention for machine
resources. For classes of models where the first
solution found by the MIP solver is almost always
optimal, and that solution isn’t found at the root, it
is often better to allow a single thread to explore
the search tree uncontested. Another situation where
reducing the thread count can be helpful is when
memory is tight. Each thread can consume a significant
amount of memory. We’ve made the pragmatic choice to
impose a soft limit of 32 threads for the automatic
setting (0). If your machine has more, and you find
that using more increases performance, you should feel
free to set the parameter to a larger value.
-TimeLimit TIMELIMIT, --TimeLimit TIMELIMIT
[env var: TIMELIMIT] (default: 1e+100) (type: float):
Limits the total time expended (in seconds).
Optimization returns with a TIME_LIMIT status if the
limit is exceeded. Note that optimization may not stop
immediately upon hitting the time limit. It will stop
after performing the required additional computations
of the attributes associated with the terminated
optimization. As a result, the Runtime attribute may
be larger than the specified TimeLimit upon
completion, and repeating the optimization with a
TimeLimit set to the Runtime attribute of the stopped
optimization may result in additional computations and
a larger attribute value. This parameter is callback
settable. It can be changed from within a callback
when the "where" value is "PRESOLVED", "SIMPLEX",
"MIP", "MIPSOL", "MIPNODE", "BARRIER", or "MULTIOBJ"
(see the Callback Codes section for more information).
How to do that for the different APIs is illustrated
here. In case of a remote server, the change of a
parameter from within a callback may not be taken into
account immediately.
-TokenServer TOKENSERVER, --TokenServer TOKENSERVER
[env var: TOKENSERVER] (default: ) (type: str): When
using a token license, set this parameter to the name
of the token server. You can refer to the server using
its name or its IP address. You can provide a comma-
separated list of token servers to increase
robustness. If the first server in the list doesn’t
respond, the second will be tried, etc. You must set
this parameter through either a "gurobi.lic" file
(using "TOKENSERVER=server") or an empty environment.
Changing the parameter after your environment has been
created will have no effect.
-TuneCleanup TUNECLEANUP, --TuneCleanup TUNECLEANUP
[env var: TUNECLEANUP] (default: 0.0) (type: float):
Enables a cleanup phase at the end of tuning. The
parameter indicates the percentage of total tuning
time to devote to this phase, with a goal of reducing
the number of parameter changes required to achieve
the best tuning result.
-TuneCriterion TUNECRITERION, --TuneCriterion TUNECRITERION
[env var: TUNECRITERION] (default: -1) (type: int):
Modifies the tuning criterion for the tuning tool. The
primary tuning criterion is always to minimize the
runtime required to find a proven optimal solution.
However, for MIP models that don’t solve to optimality
within the specified time limit, a secondary criterion
is needed. Set this parameter to 1 to use the
optimality gap as the secondary criterion. Choose a
value of 2 to use the objective of the best feasible
solution found. Choose a value of 3 to use the best
objective bound. Choose 0 to ignore the secondary
criterion and focus entirely on minimizing the time to
find a proven optimal solution. The default value of
-1 chooses automatically. Note that values 1 and 3 are
unsupported for multi-objective problems.
-TuneDynamicJobs TUNEDYNAMICJOBS, --TuneDynamicJobs TUNEDYNAMICJOBS
[env var: TUNEDYNAMICJOBS] (default: 0) (type: int):
Enables distributed parallel tuning, which can
significantly increase the performance of the tuning
tool. A value of "n" causes the tuning tool to use a
dynamic set of up to "n" workers in parallel. These
workers are used for a limited amount of time and
afterwards potentially released so that they are
available for other remote jobs. A value of "-1"
allows the solver to use an unlimited number of
workers. Note that this parameter can be combined with
TuneJobs to get a static set of workers and a dynamic
set of workers for distributed tuning. You can use the
WorkerPool parameter to provide a distributed worker
cluster. Note that distributed tuning is most
effective when the worker machines have similar
performance. Distributed tuning doesn’t attempt to
normalize performance by server, so it can incorrectly
attribute a boost in performance to a parameter change
when the associated setting is tried on a worker that
is significantly faster than the others.
-TuneJobs TUNEJOBS, --TuneJobs TUNEJOBS
[env var: TUNEJOBS] (default: 0) (type: int): Enables
distributed parallel tuning, which can significantly
increase the performance of the tuning tool. A value
of "n" causes the tuning tool to use a static set of
up to "n" workers in parallel. Such workers are kept
for the whole tuning run. Note that this parameter can
be combined with TuneDynamicJobs to get a static set
of workers and a dynamic set of workers for
distributed tuning. You can use the WorkerPool
parameter to provide a distributed worker cluster.
Note that distributed tuning is most effective when
the worker machines have similar performance.
Distributed tuning doesn’t attempt to normalize
performance by server, so it can incorrectly attribute
a boost in performance to a parameter change when the
associated setting is tried on a worker that is
significantly faster than the others.
-TuneMetric TUNEMETRIC, --TuneMetric TUNEMETRIC
[env var: TUNEMETRIC] (default: -1) (type: int): A
single tuning run typically produces multiple timing
results for each candidate parameter set, either as a
result of performing multiple trials, or tuning
multiple models, or both. This parameter controls how
these results are aggregated into a single measure.
The default setting (-1) chooses the aggregation
automatically; setting 0 computes the average of all
individual results; setting 1 takes the maximum.
-TuneOutput TUNEOUTPUT, --TuneOutput TUNEOUTPUT
[env var: TUNEOUTPUT] (default: 2) (type: int):
Controls the amount of output produced by the tuning
tool. Level 0 produces no output; level 1 produces
tuning summary output only when a new best parameter
set is found; level 2 produces tuning summary output
for each parameter set that is tried; level 3 produces
tuning summary output, plus detailed solver output,
for each parameter set tried.
-TuneResults TUNERESULTS, --TuneResults TUNERESULTS
[env var: TUNERESULTS] (default: -1) (type: int): The
tuning tool often finds multiple parameter sets that
improve over the baseline settings. This parameter
controls how many of these sets should be retained
when tuning is complete. A non-negative value
indicates how many sets should be retained. The
default value (-1) retains the efficient frontier of
parameter sets. That is, it retains the best set for
one changed parameter, the best for two changed
parameters, etc. Sets that aren’t on the efficient
frontier are discarded. If you interested in all the
sets, use value -2 for the parameter. Note that the
first set in the results is always the set of
parameters which was used for the first solve, the
baseline settings. This set serves as the base for any
improvement. So if you are interested in the best
tuned set of parameters you need to request at least 2
tune results. The first one (with index 0) will be the
baseline setting and the second one (with index 1)
will be the best set found during tuning.
-TuneTargetMIPGap TUNETARGETMIPGAP, --TuneTargetMIPGap TUNETARGETMIPGAP
[env var: TUNETARGETMIPGAP] (default: 0.0) (type:
float): A target gap to be reached. As soon as the
tuner has found parameter settings that allow Gurobi
to reach the target gap for the given model(s), it
stops trying to improve parameter settings further.
Instead, the tuner switches into the cleanup phase
(see TuneCleanup parameter).
-TuneTargetTime TUNETARGETTIME, --TuneTargetTime TUNETARGETTIME
[env var: TUNETARGETTIME] (default: 0.005) (type:
float): A target runtime in seconds to be reached. As
soon as the tuner has found parameter settings that
allow Gurobi to solve the model(s) within the target
runtime, it stops trying to improve parameter settings
further. Instead, the tuner switches into the cleanup
phase (see TuneCleanup parameter).
-TuneTimeLimit TUNETIMELIMIT, --TuneTimeLimit TUNETIMELIMIT
[env var: TUNETIMELIMIT] (default: 1e+100) (type:
float): Limits total tuning runtime (in seconds). The
default setting chooses a time limit automatically.
-TuneTrials TUNETRIALS, --TuneTrials TUNETRIALS
[env var: TUNETRIALS] (default: 0) (type: int):
Performance on a MIP model can sometimes experience
significant variations due to random effects. As a
result, the tuning tool may return parameter sets that
improve on the baseline only due to randomness. This
parameter allows you to perform multiple solves for
each parameter set, using different Seed values for
each, in order to reduce the influence of randomness
on the results. The default value of 0 indicates an
automatic choice that depends on model
characteristics.
-UpdateMode UPDATEMODE, --UpdateMode UPDATEMODE
[env var: UPDATEMODE] (default: 1) (type: int):
Determines how newly added variables and linear
constraints are handled. The default setting (1)
allows you to use new variables and constraints
immediately for building or modifying the model. A
setting of 0 requires you to call "update" before
these can be used. Since the vast majority of programs
never query Gurobi for details about the optimization
models they build, the default setting typically
removes the need to call "update", or even be aware of
the details of our *lazy update* approach for handling
model modifications. However, these details will show
through when you try to query modified model
information. In the Gurobi interface, model
modifications (bound changes, right- hand side
changes, objective changes, etc.) are placed in a
queue. These queued modifications are applied to the
model at three times: when you call "update", when you
call "optimize", or when you call "write" to write the
model to disk. When you query information about the
model, the result will depend on both *whether* that
information was modified and *when* it was modified.
In particular, no matter what setting of UpdateMode
you use, if the modification is sitting in the queue,
you’ll get the result from before the modification. To
expand on this a bit, all attribute modifications are
actually placed in a queue. This includes attributes
that may not traditionally be viewed as being part of
the model, including things like variable branching
priorities, constraint basis statuses, etc. Querying
the values of these attributes will return their
previous values if subsequent modifications are still
in the queue. The only potential benefit to changing
the parameter to 0 is that in unusual cases this
setting may allow simplex to make more aggressive use
of warm-start information after a model modification.
If you want to change this parameter, you need to set
it as soon as you create your Gurobi environment. Note
that you still need to call "update" to modify an
attribute on an SOS constraint, quadratic constraint,
or general constraint.
-VarBranch VARBRANCH, --VarBranch VARBRANCH
[env var: VARBRANCH] (default: -1) (type: int):
Controls the branch variable selection strategy. The
default -1 setting makes an automatic choice,
depending on problem characteristics. Available
alternatives are Pseudo Reduced Cost Branching (0),
Pseudo Shadow Price Branching (1), Maximum
Infeasibility Branching (2), and Strong Branching (3).
Changing the value of this parameter rarely produces a
significant benefit. Note: Only affects mixed integer
programming (MIP) models
-WLSAccessID WLSACCESSID, --WLSAccessID WLSACCESSID
[env var: WLSACCESSID] (default: ) (type: str): When
using a WLS license, set this parameter to the access
ID for your license. You can retrieve this string from
your account on the Gurobi Web License Manager site.
-WLSConfig WLSCONFIG, --WLSConfig WLSCONFIG
[env var: WLSCONFIG] (default: ) (type: str): When
using a WLS On Demand license, this parameter can be
used to specify which configuration to use. If not
specified, the configuration used will be the default
configuration specified for that license.
-WLSProxy WLSPROXY, --WLSProxy WLSPROXY
[env var: WLSPROXY] (default: ) (type: str): Comma
separated list of addresses of the WLS proxies to
connect to. When using a WLS On Demand license, this
parameter can be used to specify the URLs to which
Gurobi will connect to report usage. The default value
(an empty string) is equivalent to
"http://localhost:61099".
-WLSSecret WLSSECRET, --WLSSecret WLSSECRET
[env var: WLSSECRET] (default: ) (type: str): When
using a WLS license, set this parameter to the secret
key for your license. You can retrieve this string
from your account on the Gurobi Web License Manager
site.
-WLSToken WLSTOKEN, --WLSToken WLSTOKEN
[env var: WLSTOKEN] (default: ) (type: str): If you
are using a WLS license and have retrieved your own
token through the WLS REST API, use this parameter to
pass that token to the library. If you do this, you
don’t need to set any other WLS-related parameters.
-WLSTokenDuration WLSTOKENDURATION, --WLSTokenDuration WLSTOKENDURATION
[env var: WLSTOKENDURATION] (default: 0) (type: int):
When using a WLS license, this parameter can be used
to adjust the lifespan (in minutes) of a token. A
token enables Gurobi to run on that client for the
life of the token. Gurobi will automatically request a
new token if the current one expires, but it won’t
notify the WLS server if it completes its work before
the current token expires. A shorter lifespan is
better for short-lived usage. A longer lifespan is
better for environments where the network connection
to the WLS server is unreliable. The default value of
0 means ‘automatic’, and is currently equal to 5
minutes. This value may change in the future. The WLS
server will cap the chosen value automatically to be
at least 5 minutes and no more than 60 minutes. This
behavior may change in the future as well.
-WLSTokenRefresh WLSTOKENREFRESH, --WLSTokenRefresh WLSTOKENREFRESH
[env var: WLSTOKENREFRESH] (default: 0.9) (type:
float): The value specifies the fraction of the token
duration after which a token refresh is triggered. So,
for example, if the token duration is 30 minutes and
WLSTokenRefresh is set to 0.6, the token will be
refreshed every 18 minutes. The minimum refresh
interval is 4 minutes.
-WorkLimit WORKLIMIT, --WorkLimit WORKLIMIT
[env var: WORKLIMIT] (default: 1e+100) (type: float):
Limits the total work expended (in work units).
Optimization returns with a WORK_LIMIT status if the
limit is exceeded. In contrast to the TimeLimit, work
limits are deterministic. This means that on the same
hardware and with the same parameter and attribute
settings, a work limit will stop the optimization of a
given model at the exact same point every time. One
work unit corresponds very roughly to one second on a
single thread, but this greatly depends on the
hardware on which Gurobi is running and the model that
is being solved. Note that optimization may not stop
immediately upon hitting the work limit. It will stop
when the optimization is next in a deterministic
state, and it will then perform the required
additional computations of the attributes associated
with the terminated optimization. As a result, the
Work attribute may be larger than the specified
WorkLimit upon completion, and repeating the
optimization with a WorkLimit set to the Work
attribute of the stopped optimization may result in
additional computations and a larger attribute value.
This parameter is callback settable. It can be changed
from within a callback when the "where" value is
"PRESOLVED", "SIMPLEX", "MIP", "MIPSOL", "MIPNODE",
"BARRIER", or "MULTIOBJ" (see the Callback Codes
section for more information). How to do that for the
different APIs is illustrated here. In case of a
remote server, the change of a parameter from within a
callback may not be taken into account immediately.
-WorkerPassword WORKERPASSWORD, --WorkerPassword WORKERPASSWORD
[env var: WORKERPASSWORD] (default: ) (type: str):
When using a distributed algorithm (distributed MIP,
distributed concurrent, or distributed tuning), this
parameter allows you to specify the password for the
distributed worker cluster provided in the WorkerPool
parameter.
-WorkerPool WORKERPOOL, --WorkerPool WORKERPOOL
[env var: WORKERPOOL] (default: ) (type: str): When
using a distributed algorithm (distributed MIP,
distributed concurrent, or distributed tuning), this
parameter allows you to specify a Remote Services
cluster that will provide distributed workers. You
should also specify the access password for that
cluster, if there is one, in the WorkerPassword
parameter. Note that you don’t need to set either of
these parameters if your job is running on a Compute
Server node and you want to use the same cluster for
the distributed workers. You can provide a comma-
separated list of machines for added robustness. If
the first node in the list is unavailable, the client
will attempt to contact the second node, etc. To give
an example, if you have a Remote Services cluster that
uses port 61000 on a pair of machines named "server1"
and "server2", you could set WorkerPool to
""server1:61000"" or ""server1:61000,server2:61000"".
-ZeroHalfCuts ZEROHALFCUTS, --ZeroHalfCuts ZEROHALFCUTS
[env var: ZEROHALFCUTS] (default: -1) (type: int):
Controls zero-half cut generation. Use 0 to disable
these cuts, 1 for moderate cut generation, or 2 for
aggressive cut generation. The default -1 value
chooses automatically. Overrides the Cuts parameter.
Note: Only affects mixed integer programming (MIP)
models
-ZeroObjNodes ZEROOBJNODES, --ZeroObjNodes ZEROOBJNODES
[env var: ZEROOBJNODES] (default: -1) (type: int):
Number of nodes to explore in the zero objective
heuristic. This heuristic is quite expensive, and
generally produces poor quality solutions. You should
generally only use it if other means, including
exploration of the tree with default settings, fail to
produce a feasible solution. Note: Only affects mixed
integer programming (MIP) models
Copy
You can merge nextmv.Options together using the merge method.
import nextmv_gurobipy as ngp
import nextmv
opt = nextmv.Options(
nextmv.Parameter("input", str, "", "Path to input file. Default is stdin.", False),
nextmv.Parameter("output", str, "", "Path to output file. Default is stdout.", False),
)
gp_opt = ngp.ModelOptions().to_nextmv()
options = opt.merge(gp_opt)
Copy
$ python main.py --help
usage: main.py [options]
Options for main.py. Use command-line arguments (highest precedence) or
environment variables.
options:
-h, --help show this help message and exit
-input INPUT, --input INPUT
[env var: INPUT] (default: ) (type: str): Path to
input file. Default is stdin.
-output OUTPUT, --output OUTPUT
[env var: OUTPUT] (default: ) (type: str): Path to
output file. Default is stdout.
-AggFill AGGFILL, --AggFill AGGFILL
[env var: AGGFILL] (default: -1) (type: int): Controls
the amount of fill allowed during presolve
aggregation. Larger values generally lead to presolved
models with fewer rows and columns, but with more
constraint matrix non-zeros. The default value chooses
automatically, and usually works well.
-Aggregate AGGREGATE, --Aggregate AGGREGATE
[env var: AGGREGATE] (default: 1) (type: int):
Controls the aggregation level in presolve. The
options are off (0), moderate (1), or aggressive (2).
In rare instances, aggregation can lead to an
accumulation of numerical errors. Turning it off can
sometimes improve solution accuracy.
-BQPCuts BQPCUTS, --BQPCuts BQPCUTS
[env var: BQPCUTS] (default: -1) (type: int): Controls
Boolean Quadric Polytope (BQP) cut generation. Use 0
...
...
Copy
Notice how the ModelOptions are merged with the nextmv.Options and you can access the options from both sets.