public class GRBModel extends Object
addVar (adds a new decision
variable to the model), addConstr (adds a new constraint to the model), optimize (optimizes the current
model), and get (retrieves the
value of an attribute).
While the Java garbage collector will eventually collect an unused
GRBModel object, the vast majority of the memory associated
with a model is stored outside of the Java heap. As a result, the
garbage collector can't see this memory usage, and thus it can't take
this quantity into account when deciding whether collection is
necessary. We recommend that you call GRBModel.dispose when you are done
using a model.
| Constructor and Description |
|---|
GRBModel(GRBEnv env)
Model constructor.
|
GRBModel(GRBEnv env,
String filename)
Read a model from a file.
|
GRBModel(GRBModel model)
Create a copy of an existing model.
|
GRBModel(GRBModel model,
GRBEnv targetenv)
Copy an existing model to a different environment.
|
| Modifier and Type | Method and Description |
|---|---|
GRBConstr |
addConstr(double lhs,
char sense,
GRBLinExpr rhsExpr,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(double lhs,
char sense,
GRBVar rhsVar,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(GRBLinExpr lhsExpr,
char sense,
double rhs,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(GRBLinExpr lhsExpr,
char sense,
GRBLinExpr rhsExpr,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(GRBLinExpr lhsExpr,
char sense,
GRBVar rhsVar,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(GRBVar lhsVar,
char sense,
double rhs,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(GRBVar lhsVar,
char sense,
GRBLinExpr rhsExpr,
String name)
Add a single linear constraint to a model.
|
GRBConstr |
addConstr(GRBVar lhsVar,
char sense,
GRBVar rhsVar,
String name)
Add a single linear constraint to a model.
|
GRBConstr[] |
addConstrs(GRBLinExpr[] lhsExprs,
char[] senses,
double[] rhss,
String[] names)
Add new linear constraints to a model.
|
GRBConstr[] |
addConstrs(GRBLinExpr[] lhsExprs,
char[] senses,
double[] rhss,
String[] names,
int start,
int len)
Add new linear constraints to a model.
|
GRBConstr[] |
addConstrs(int count)
Add
count new linear constraints to a model. |
GRBGenConstr |
addGenConstrAbs(GRBVar resvar,
GRBVar argvar,
String name)
Add a new general constraint of type GRB.GENCONSTR_ABS to a
model.
|
GRBGenConstr |
addGenConstrAnd(GRBVar resvar,
GRBVar[] vars,
String name)
Add a new general constraint of type GRB.GENCONSTR_AND to a
model.
|
GRBGenConstr |
addGenConstrCos(GRBVar xvar,
GRBVar yvar,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_COS to a
model.
|
GRBGenConstr |
addGenConstrExp(GRBVar xvar,
GRBVar yvar,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_EXP to a
model.
|
GRBGenConstr |
addGenConstrExpA(GRBVar xvar,
GRBVar yvar,
double a,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_EXPA to
a model.
|
GRBGenConstr |
addGenConstrIndicator(GRBVar binvar,
int binval,
GRBLinExpr expr,
char sense,
double rhs,
String name)
Add a new general constraint of type GRB.GENCONSTR_INDICATOR to a model.
|
GRBGenConstr |
addGenConstrLog(GRBVar xvar,
GRBVar yvar,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_LOG to a
model.
|
GRBGenConstr |
addGenConstrLogA(GRBVar xvar,
GRBVar yvar,
double a,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_LOGA to
a model.
|
GRBGenConstr |
addGenConstrLogistic(GRBVar xvar,
GRBVar yvar,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_LOGISTIC
to a model.
|
GRBGenConstr |
addGenConstrMax(GRBVar resvar,
GRBVar[] vars,
double constant,
String name)
Add a new general constraint of type GRB.GENCONSTR_MAX to a
model.
|
GRBGenConstr |
addGenConstrMin(GRBVar resvar,
GRBVar[] vars,
double constant,
String name)
Add a new general constraint of type GRB.GENCONSTR_MIN to a
model.
|
GRBGenConstr |
addGenConstrNL(GRBVar yvar,
int[] opcode,
double[] data,
int[] parent,
String name) |
GRBGenConstr |
addGenConstrNorm(GRBVar resvar,
GRBVar[] vars,
double which,
String name)
Add a new general constraint of type GRB.GENCONSTR_NORM to
a model.
|
GRBGenConstr |
addGenConstrOr(GRBVar resvar,
GRBVar[] vars,
String name)
Add a new general constraint of type GRB.GENCONSTR_OR to a
model.
|
GRBGenConstr |
addGenConstrPoly(GRBVar xvar,
GRBVar yvar,
double[] p,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_POLY to
a model.
|
GRBGenConstr |
addGenConstrPow(GRBVar xvar,
GRBVar yvar,
double a,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_POW to a
model.
|
GRBGenConstr |
addGenConstrPWL(GRBVar xvar,
GRBVar yvar,
double[] xpts,
double[] ypts,
String name)
Add a new general constraint of type GRB.GENCONSTR_PWL to a
model.
|
GRBGenConstr |
addGenConstrSin(GRBVar xvar,
GRBVar yvar,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_SIN to a
model.
|
GRBGenConstr |
addGenConstrTan(GRBVar xvar,
GRBVar yvar,
String name,
String options)
Add a new general constraint of type GRB.GENCONSTR_TAN to a
model.
|
GRBQConstr |
addQConstr(double lhs,
char sense,
GRBQuadExpr rhsExpr,
String name)
Add a quadratic constraint to a model.
|
GRBQConstr |
addQConstr(GRBLinExpr lhsExpr,
char sense,
GRBQuadExpr rhsExpr,
String name)
Add a quadratic constraint to a model.
|
GRBQConstr |
addQConstr(GRBQuadExpr lhsExpr,
char sense,
double rhs,
String name)
Add a quadratic constraint to a model.
|
GRBQConstr |
addQConstr(GRBQuadExpr lhsExpr,
char sense,
GRBLinExpr rhsExpr,
String name)
Add a quadratic constraint to a model.
|
GRBQConstr |
addQConstr(GRBQuadExpr lhsExpr,
char sense,
GRBQuadExpr rhsExpr,
String name)
Add a quadratic constraint to a model.
|
GRBQConstr |
addQConstr(GRBQuadExpr lhsExpr,
char sense,
GRBVar rhsVar,
String name)
Add a quadratic constraint to a model.
|
GRBQConstr |
addQConstr(GRBVar lhsVar,
char sense,
GRBQuadExpr rhsExpr,
String name)
Add a quadratic constraint to a model.
|
GRBConstr |
addRange(GRBLinExpr expr,
double lower,
double upper,
String name)
Add a single range constraint to a model.
|
GRBConstr[] |
addRanges(GRBLinExpr[] exprs,
double[] lower,
double[] upper,
String[] names)
Add new range constraints to a model.
|
GRBSOS |
addSOS(GRBVar[] vars,
double[] weights,
int type)
Add an SOS constraint to the model.
|
GRBVar |
addVar(double lb,
double ub,
double obj,
char type,
GRBColumn col,
String name)
Add a variable to a model.
|
GRBVar |
addVar(double lb,
double ub,
double obj,
char type,
GRBConstr[] constrs,
double[] coeffs,
String name)
Add a variable to a model, and the associated non-zero coefficients.
|
GRBVar |
addVar(double lb,
double ub,
double obj,
char type,
String name)
Add a variable to a model; non-zero entries will be added later.
|
GRBVar[] |
addVars(double[] lb,
double[] ub,
double[] obj,
char[] type,
String[] names)
Add new decision variables to a model.
|
GRBVar[] |
addVars(double[] lb,
double[] ub,
double[] obj,
char[] type,
String[] names,
GRBColumn[] cols)
Add new decision variables to a model.
|
GRBVar[] |
addVars(double[] lb,
double[] ub,
double[] obj,
char[] type,
String[] names,
int start,
int len)
Add new decision variables to a model.
|
GRBVar[] |
addVars(int count,
char type)
Add
count new decision variables to a model. |
void |
BasisHead(int[] bhead) |
int |
BinvColj(int col,
int[] xind,
double[] xval) |
int |
Binvi(int i,
int[] xind,
double[] xval) |
int |
Binvj(int j,
int[] xind,
double[] xval) |
int |
BinvRowi(int i,
int[] xind,
double[] xval) |
int |
BSolve(int blen,
int[] bind,
double[] bval,
int[] xind,
double[] xval) |
void |
check() |
void |
chgCoeff(GRBConstr constr,
GRBVar var,
double newval)
Change one coefficient in the model.
|
void |
chgCoeffs(GRBConstr[] constrs,
GRBVar[] vars,
double[] newvals)
Change a list of coefficients in the model.
|
void |
computeIIS()
Compute an Irreducible Inconsistent Subsystem (IIS).
|
void |
convertToFixed() |
void |
discardConcurrentEnvs()
Discard concurrent environments for a model.
|
void |
discardMultiobjEnvs()
Use
getMultiobjEnv
to create a multi-objective environments. |
void |
dispose()
Release the resources associated with a
GRBModel object. |
GRBModel |
dualize() |
GRBModel |
feasibility() |
double |
feasRelax(int relaxobjtype,
boolean minrelax,
boolean vrelax,
boolean crelax)
Simplified method for creating a feasibility relaxation model.
|
double |
feasRelax(int relaxobjtype,
boolean minrelax,
GRBVar[] vars,
double[] lbpen,
double[] ubpen,
GRBConstr[] constrs,
double[] rhspen)
Create a feasibility relaxation model.
|
protected void |
finalize() |
GRBModel |
fixedModel()
Create the fixed model associated with a MIP model.
|
int |
FSolve(int blen,
int[] bind,
double[] bval,
int[] xind,
double[] xval) |
char[] |
get(GRB.CharAttr attr,
GRBConstr[] constrs)
Query a char-valued constraint attribute for an array of constraints.
|
char[][] |
get(GRB.CharAttr attr,
GRBConstr[][] constrs)
Query a char-valued constraint attribute for a two-dimensional array
of constraints.
|
char[][][] |
get(GRB.CharAttr attr,
GRBConstr[][][] constrs)
Query a char-valued constraint attribute for a three-dimensional array
of constraints.
|
char[] |
get(GRB.CharAttr attr,
GRBConstr[] constrs,
int start,
int len)
Query a char-valued constraint attribute for a sub-array of
constraints.
|
char[] |
get(GRB.CharAttr attr,
GRBQConstr[] qconstrs)
Query a char-valued quadratic constraint attribute for an array of
quadratic constraints.
|
char[][] |
get(GRB.CharAttr attr,
GRBQConstr[][] qconstrs)
Query a char-valued quadratic constraint attribute for a two-
dimensional array of quadratic constraints.
|
char[][][] |
get(GRB.CharAttr attr,
GRBQConstr[][][] qconstrs)
Query a char-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
char[] |
get(GRB.CharAttr attr,
GRBQConstr[] qconstrs,
int start,
int len)
Query a char-valued quadratic constraint attribute for a sub-array of
quadratic constraints.
|
char[] |
get(GRB.CharAttr attr,
GRBVar[] vars)
Query a char-valued variable attribute for an array of variables.
|
char[][] |
get(GRB.CharAttr attr,
GRBVar[][] vars)
Query a char-valued variable attribute for a two-dimensional array of
variables.
|
char[][][] |
get(GRB.CharAttr attr,
GRBVar[][][] vars)
Query a char-valued variable attribute for a three-dimensional array
of variables.
|
char[] |
get(GRB.CharAttr attr,
GRBVar[] vars,
int start,
int len)
Query a char-valued variable attribute for a sub-array of variables.
|
double |
get(GRB.DoubleAttr attr)
Query the value of a double-valued model attribute.
|
double[] |
get(GRB.DoubleAttr attr,
GRBConstr[] constrs)
Query a double-valued constraint attribute for an array of
constraints.
|
double[][] |
get(GRB.DoubleAttr attr,
GRBConstr[][] constrs)
Query a double-valued constraint attribute for a two-dimensional array
of constraints.
|
double[][][] |
get(GRB.DoubleAttr attr,
GRBConstr[][][] constrs)
Query a double-valued constraint attribute for a three-dimensional
array of constraints.
|
double[] |
get(GRB.DoubleAttr attr,
GRBConstr[] constrs,
int start,
int len)
Query a double-valued constraint attribute for a sub-array of
constraints.
|
double[] |
get(GRB.DoubleAttr attr,
GRBQConstr[] qconstrs)
Query a double-valued quadratic constraint attribute for an array of
quadratic constraints.
|
double[][] |
get(GRB.DoubleAttr attr,
GRBQConstr[][] qconstrs)
Query a double-valued quadratic constraint attribute for a two-
dimensional array of quadratic constraints.
|
double[][][] |
get(GRB.DoubleAttr attr,
GRBQConstr[][][] qconstrs)
Query a double-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
double[] |
get(GRB.DoubleAttr attr,
GRBQConstr[] qconstrs,
int start,
int len)
Query a double-valued quadratic constraint attribute for a sub-array
of quadratic constraints.
|
double[] |
get(GRB.DoubleAttr attr,
GRBVar[] vars)
Query a double-valued variable attribute for an array of variables.
|
double[][] |
get(GRB.DoubleAttr attr,
GRBVar[][] vars)
Query a double-valued variable attribute for a two-dimensional array
of variables.
|
double[][][] |
get(GRB.DoubleAttr attr,
GRBVar[][][] vars)
Query a double-valued variable attribute for a three-dimensional array
of variables.
|
double[] |
get(GRB.DoubleAttr attr,
GRBVar[] vars,
int start,
int len)
Query a double-valued variable attribute for a sub-array of variables.
|
double |
get(GRB.DoubleParam param)
Query the value of a double-valued parameter.
|
int |
get(GRB.IntAttr attr)
Query the value of an int-valued model attribute.
|
int[] |
get(GRB.IntAttr attr,
GRBConstr[] constrs)
Query an int-valued constraint attribute for an array of constraints.
|
int[][] |
get(GRB.IntAttr attr,
GRBConstr[][] constrs)
Query an int-valued constraint attribute for a two-dimensional array
of constraints.
|
int[][][] |
get(GRB.IntAttr attr,
GRBConstr[][][] constrs)
Query an int-valued constraint attribute for a three-dimensional array
of constraints.
|
int[] |
get(GRB.IntAttr attr,
GRBConstr[] constrs,
int start,
int len)
Query an int-valued constraint attribute for a sub-array of
constraints.
|
int[] |
get(GRB.IntAttr attr,
GRBGenConstr[] genconstrs)
Query an int-valued general constraint attribute for an array of
general constraints.
|
int[][] |
get(GRB.IntAttr attr,
GRBGenConstr[][] genconstrs)
Query an int-valued general constraint attribute for a two-dimensional
array of general constraints.
|
int[][][] |
get(GRB.IntAttr attr,
GRBGenConstr[][][] genconstrs)
Query an int-valued general constraint attribute for a three-
dimensional array of general constraints.
|
int[] |
get(GRB.IntAttr attr,
GRBGenConstr[] genconstrs,
int start,
int len)
Query an int-valued general constraint attribute for a sub-array of
general constraints.
|
int[] |
get(GRB.IntAttr attr,
GRBQConstr[] qconstrs)
Query an int-valued quadratic constraint attribute for an array of
quadratic constraints.
|
int[][] |
get(GRB.IntAttr attr,
GRBQConstr[][] qconstrs)
Query an int-valued quadratic constraint attribute for a two-
dimensional array of quadratic constraints.
|
int[][][] |
get(GRB.IntAttr attr,
GRBQConstr[][][] qconstrs)
Query an int-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
int[] |
get(GRB.IntAttr attr,
GRBQConstr[] qconstrs,
int start,
int len)
Query an int-valued quadratic constraint attribute for a sub-array of
quadratic constraints.
|
int[] |
get(GRB.IntAttr attr,
GRBVar[] vars)
Query an int-valued variable attribute for an array of variables.
|
int[][] |
get(GRB.IntAttr attr,
GRBVar[][] vars)
Query an int-valued variable attribute for a two-dimensional array of
variables.
|
int[][][] |
get(GRB.IntAttr attr,
GRBVar[][][] vars)
Query an int-valued variable attribute for a three-dimensional array
of variables.
|
int[] |
get(GRB.IntAttr attr,
GRBVar[] vars,
int start,
int len)
Query an int-valued variable attribute for a sub-array of variables.
|
int |
get(GRB.IntParam param)
Query the value of an int-valued parameter.
|
String |
get(GRB.StringAttr attr)
Query the value of a string-valued model attribute.
|
String[] |
get(GRB.StringAttr attr,
GRBConstr[] constrs)
Query a String-valued constraint attribute for an array of
constraints.
|
String[][] |
get(GRB.StringAttr attr,
GRBConstr[][] constrs)
Query a String-valued constraint attribute for a two-dimensional array
of constraints.
|
String[][][] |
get(GRB.StringAttr attr,
GRBConstr[][][] constrs)
Query a String-valued constraint attribute for a three-dimensional
array of constraints.
|
String[] |
get(GRB.StringAttr attr,
GRBConstr[] constrs,
int start,
int len)
Query a String-valued constraint attribute for a sub-array of
constraints.
|
String[] |
get(GRB.StringAttr attr,
GRBGenConstr[] genconstrs)
Query a String-valued general constraint attribute for an array of
general constraints.
|
String[][] |
get(GRB.StringAttr attr,
GRBGenConstr[][] genconstrs)
Query a String-valued constraint attribute for a two-dimensional array
of general constraints.
|
String[][][] |
get(GRB.StringAttr attr,
GRBGenConstr[][][] genconstrs)
Query a String-valued constraint attribute for a three-dimensional
array of general constraints.
|
String[] |
get(GRB.StringAttr attr,
GRBGenConstr[] genconstrs,
int start,
int len)
Query a String-valued general constraint attribute for a sub-array of
constraints.
|
String[] |
get(GRB.StringAttr attr,
GRBQConstr[] qconstrs)
Query a String-valued quadratic constraint attribute for an array of
quadratic constraints.
|
String[][] |
get(GRB.StringAttr attr,
GRBQConstr[][] qconstrs)
Query a String-valued quadratic constraint attribute for a two-
dimensional array of quadratic constraints.
|
String[][][] |
get(GRB.StringAttr attr,
GRBQConstr[][][] qconstrs)
Query a String-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
String[] |
get(GRB.StringAttr attr,
GRBQConstr[] qconstrs,
int start,
int len)
Query a String-valued quadratic constraint attribute for a sub-array
of quadratic constraints.
|
String[] |
get(GRB.StringAttr attr,
GRBVar[] vars)
Query a String-valued variable attribute for an array of variables.
|
String[][] |
get(GRB.StringAttr attr,
GRBVar[][] vars)
Query a String-valued variable attribute for a two-dimensional array
of variables.
|
String[][][] |
get(GRB.StringAttr attr,
GRBVar[][][] vars)
Query a String-valued variable attribute for a three-dimensional array
of variables.
|
String[] |
get(GRB.StringAttr attr,
GRBVar[] vars,
int start,
int len)
Query a String-valued variable attribute for a sub-array of variables.
|
String |
get(GRB.StringParam param)
Query the value of a string-valued parameter.
|
double |
getCoeff(GRBConstr constr,
GRBVar var)
Query the coefficient of variable
var in linear constraint
constr (note that the result can be zero). |
GRBColumn |
getCol(GRBVar var)
Retrieve the list of constraints in which a variable participates, and
the associated coefficients.
|
GRBEnv |
getConcurrentEnv(int num)
Create/retrieve a concurrent environment for a model.
|
GRBConstr |
getConstr(int i) |
GRBConstr |
getConstrByName(String name)
Retrieve a linear constraint from its name.
|
GRBConstr[] |
getConstrs()
Retrieve an array of all linear constraints in the model.
|
GRBEnv |
getEnv() |
void |
getGenConstrAbs(GRBGenConstr genc,
GRBVar[] resvar,
GRBVar[] argvar)
Any of the following arguments can be null.
|
void |
getGenConstrAnd(GRBGenConstr genc,
GRBVar[] resvar,
GRBVar[] vars,
int[] len)
Any of the following arguments can be null.
|
void |
getGenConstrCos(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar)
Any of the following arguments can be null.
|
void |
getGenConstrExp(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar)
Any of the following arguments can be null.
|
void |
getGenConstrExpA(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar,
double[] a)
Any of the following arguments can be null.
|
void |
getGenConstrIndicator(GRBGenConstr genc,
GRBVar[] binvar,
int[] binval,
GRBLinExpr[] expr,
char[] sense,
double[] rhs)
Any of the following arguments can be null.
|
void |
getGenConstrLog(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar)
Any of the following arguments can be null.
|
void |
getGenConstrLogA(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar,
double[] a)
Any of the following arguments can be null.
|
void |
getGenConstrLogistic(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar)
Any of the following arguments can be null.
|
void |
getGenConstrMax(GRBGenConstr genc,
GRBVar[] resvar,
GRBVar[] vars,
int[] len,
double[] constant)
Any of the following arguments can be null.
|
void |
getGenConstrMin(GRBGenConstr genc,
GRBVar[] resvar,
GRBVar[] vars,
int[] len,
double[] constant)
Any of the following arguments can be null.
|
void |
getGenConstrNL(GRBGenConstr genc,
GRBVar[] yvar,
int[] nnodes,
int[] opcode,
double[] data,
int[] parent) |
void |
getGenConstrNorm(GRBGenConstr genc,
GRBVar[] resvar,
GRBVar[] vars,
int[] len,
double[] which)
Any of the following arguments can be null.
|
void |
getGenConstrOr(GRBGenConstr genc,
GRBVar[] resvar,
GRBVar[] vars,
int[] len)
Any of the following arguments can be null.
|
void |
getGenConstrPoly(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar,
int[] plen,
double[] p)
Any of the following arguments can be null.
|
void |
getGenConstrPow(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar,
double[] a)
Any of the following arguments can be null.
|
void |
getGenConstrPWL(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar,
int[] npts,
double[] xpts,
double[] ypts)
Any of the following arguments can be null.
|
GRBGenConstr[] |
getGenConstrs()
Retrieve an array of all general constraints in the model.
|
void |
getGenConstrSin(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar)
Any of the following arguments can be null.
|
void |
getGenConstrTan(GRBGenConstr genc,
GRBVar[] xvar,
GRBVar[] yvar)
Any of the following arguments can be null.
|
String |
getJSONSolution() |
GRBEnv |
getMultiobjEnv(int index)
Use
discardMultiobjEnvs to discard multi-objective environments and
return to standard behavior. |
GRBExpr |
getObjective()
Retrieve the optimization objective.
|
GRBLinExpr |
getObjective(int index)
Retrieve an alternative optimization objective.
|
int |
getPWLObj(GRBVar var,
double[] x,
double[] y)
Retrieve the piecewise-linear objective function for a variable.
|
GRBQConstr[] |
getQConstrs()
Retrieve an array of all quadratic constraints in the model.
|
GRBQuadExpr |
getQCRow(GRBQConstr qc)
Retrieve the left-hand side expression from a quadratic constraint.
|
GRBLinExpr |
getRow(GRBConstr constr)
Retrieve a list of variables that participate in a constraint, and the
associated coefficients.
|
int |
getSOS(GRBSOS sos,
GRBVar[] vars,
double[] weights,
int[] type)
Retrieve the list of variables that participate in an SOS constraint,
and the associated coefficients.
|
GRBSOS[] |
getSOSs()
Retrieve an array of all SOS constraints in the model.
|
void |
getTuneResult(int i)
Use this method to retrieve the results of a previous
tune call. |
GRBVar |
getVar(int i) |
GRBVar |
getVarByName(String name)
Retrieve a variable from its name.
|
GRBVar[] |
getVars()
Retrieve an array of all variables in the model.
|
GRBModel |
linearize() |
void |
optimize()
Optimize the model.
|
void |
optimizeasync()
Optimize a model asynchronously.
|
String |
optimizeBatch() |
void |
prefetchAttr(GRB.CharAttr attr) |
void |
prefetchAttr(GRB.DoubleAttr attr) |
void |
prefetchAttr(GRB.IntAttr attr) |
void |
prefetchAttr(GRB.StringAttr attr) |
GRBModel |
presolve()
Perform presolve on a model.
|
void |
read(String filename)
One variant of the constructor takes the name of the file that
contains the new model as its argument.
|
GRBModel |
relax() |
void |
remove(GRBConstr constr)
Remove a linear constraint from the model.
|
void |
remove(GRBGenConstr genconstr)
Remove a general constraint from the model.
|
void |
remove(GRBQConstr qconstr)
Remove a quadratic constraint from the model.
|
void |
remove(GRBSOS sos)
Remove an SOS constraint from the model.
|
void |
remove(GRBVar var)
Remove a variable from the model.
|
void |
reset()
Reset the model to an unsolved state, discarding any previously
computed solution information.
|
void |
reset(int clearall)
Reset the model to an unsolved state, discarding any previously
computed solution information.
|
void |
set(GRB.CharAttr attr,
GRBConstr[][][] constrs,
char[][][] newvals)
Set a char-valued constraint attribute for a three-dimensional array
of constraints.
|
void |
set(GRB.CharAttr attr,
GRBConstr[][] constrs,
char[][] newvals)
Set a char-valued constraint attribute for a two-dimensional array of
constraints.
|
void |
set(GRB.CharAttr attr,
GRBConstr[] constrs,
char[] newvals)
Set a char-valued constraint attribute for an array of constraints.
|
void |
set(GRB.CharAttr attr,
GRBConstr[] constrs,
char[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.CharAttr attr,
GRBQConstr[][][] qconstrs,
char[][][] newvals)
Set a char-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
void |
set(GRB.CharAttr attr,
GRBQConstr[][] qconstrs,
char[][] newvals)
Set a char-valued quadratic constraint attribute for a two-dimensional
array of quadratic constraints.
|
void |
set(GRB.CharAttr attr,
GRBQConstr[] qconstrs,
char[] newvals)
Set a char-valued quadratic constraint attribute for an array of
quadratic constraints.
|
void |
set(GRB.CharAttr attr,
GRBQConstr[] qconstrs,
char[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.CharAttr attr,
GRBVar[][][] vars,
char[][][] newvals)
Set a char-valued variable attribute for a three-dimensional array of
variables.
|
void |
set(GRB.CharAttr attr,
GRBVar[][] vars,
char[][] newvals)
Set a char-valued variable attribute for a two-dimensional array of
variables.
|
void |
set(GRB.CharAttr attr,
GRBVar[] vars,
char[] newvals)
Set a char-valued variable attribute for an array of variables.
|
void |
set(GRB.CharAttr attr,
GRBVar[] vars,
char[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.DoubleAttr attr,
double newval)
Set the value of a double-valued model attribute.
|
void |
set(GRB.DoubleAttr attr,
GRBConstr[][][] constrs,
double[][][] newvals)
Set a double-valued constraint attribute for a three-dimensional array
of constraints.
|
void |
set(GRB.DoubleAttr attr,
GRBConstr[][] constrs,
double[][] newvals)
Set a double-valued constraint attribute for a two-dimensional array
of constraints.
|
void |
set(GRB.DoubleAttr attr,
GRBConstr[] constrs,
double[] newvals)
Set a double-valued constraint attribute for an array of constraints.
|
void |
set(GRB.DoubleAttr attr,
GRBConstr[] constrs,
double[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.DoubleAttr attr,
GRBQConstr[][][] qconstrs,
double[][][] newvals)
Set a double-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
void |
set(GRB.DoubleAttr attr,
GRBQConstr[][] qconstrs,
double[][] newvals)
Set a double-valued quadratic constraint attribute for a two-
dimensional array of quadratic constraints.
|
void |
set(GRB.DoubleAttr attr,
GRBQConstr[] qconstrs,
double[] newvals)
Set a double-valued quadratic constraint attribute for an array of
quadratic constraints.
|
void |
set(GRB.DoubleAttr attr,
GRBQConstr[] qconstrs,
double[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.DoubleAttr attr,
GRBVar[][][] vars,
double[][][] newvals)
Set a double-valued variable attribute for a three-dimensional array
of variables.
|
void |
set(GRB.DoubleAttr attr,
GRBVar[][] vars,
double[][] newvals)
Set a double-valued variable attribute for a two-dimensional array of
variables.
|
void |
set(GRB.DoubleAttr attr,
GRBVar[] vars,
double[] newvals)
Set a double-valued variable attribute for an array of variables.
|
void |
set(GRB.DoubleAttr attr,
GRBVar[] vars,
double[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.DoubleParam param,
double newval)
Set the value of a double-valued parameter.
|
void |
set(GRB.IntAttr attr,
GRBConstr[][][] constrs,
int[][][] newvals)
Set an int-valued constraint attribute for a three-dimensional array
of constraints.
|
void |
set(GRB.IntAttr attr,
GRBConstr[][] constrs,
int[][] newvals)
Set an int-valued constraint attribute for a two-dimensional array of
constraints.
|
void |
set(GRB.IntAttr attr,
GRBConstr[] constrs,
int[] newvals)
Set an int-valued constraint attribute for an array of constraints.
|
void |
set(GRB.IntAttr attr,
GRBConstr[] constrs,
int[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.IntAttr attr,
GRBVar[][][] vars,
int[][][] newvals)
Set an int-valued variable attribute for a three-dimensional array of
variables.
|
void |
set(GRB.IntAttr attr,
GRBVar[][] vars,
int[][] newvals)
Set an int-valued variable attribute for a two-dimensional array of
variables.
|
void |
set(GRB.IntAttr attr,
GRBVar[] vars,
int[] newvals)
Set an int-valued variable attribute for an array of variables.
|
void |
set(GRB.IntAttr attr,
GRBVar[] vars,
int[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.IntAttr attr,
int newval)
Set the value of an int-valued model attribute.
|
void |
set(GRB.IntParam param,
int newval)
Set the value of an int-valued parameter.
|
void |
set(GRB.StringAttr attr,
GRBConstr[][][] constrs,
String[][][] newvals)
Set a String-valued constraint attribute for a three-dimensional array
of constraints.
|
void |
set(GRB.StringAttr attr,
GRBConstr[][] constrs,
String[][] newvals)
Set a String-valued constraint attribute for a two-dimensional array
of constraints.
|
void |
set(GRB.StringAttr attr,
GRBConstr[] constrs,
String[] newvals)
Set a String-valued constraint attribute for an array of constraints.
|
void |
set(GRB.StringAttr attr,
GRBConstr[] constrs,
String[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.StringAttr attr,
GRBGenConstr[][][] genconstrs,
String[][][] newvals)
Set a String-valued general constraint attribute for a three-
dimensional array of general constraints.
|
void |
set(GRB.StringAttr attr,
GRBGenConstr[][] genconstrs,
String[][] newvals)
Set a String-valued general constraint attribute for a two-dimensional
array of general constraints.
|
void |
set(GRB.StringAttr attr,
GRBGenConstr[] genconstrs,
String[] newvals)
Set a String-valued general constraint attribute for an array of
general constraints.
|
void |
set(GRB.StringAttr attr,
GRBGenConstr[] genconstrs,
String[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.StringAttr attr,
GRBQConstr[][][] qconstrs,
String[][][] newvals)
Set a String-valued quadratic constraint attribute for a three-
dimensional array of quadratic constraints.
|
void |
set(GRB.StringAttr attr,
GRBQConstr[][] qconstrs,
String[][] newvals)
Set a String-valued quadratic constraint attribute for a two-
dimensional array of quadratic constraints.
|
void |
set(GRB.StringAttr attr,
GRBQConstr[] qconstrs,
String[] newvals)
Set a String-valued quadratic constraint attribute for an array of
quadratic constraints.
|
void |
set(GRB.StringAttr attr,
GRBQConstr[] qconstrs,
String[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.StringAttr attr,
GRBVar[][][] vars,
String[][][] newvals)
Set a String-valued variable attribute for a three-dimensional array
of variables.
|
void |
set(GRB.StringAttr attr,
GRBVar[][] vars,
String[][] newvals)
Set a String-valued variable attribute for a two-dimensional array of
variables.
|
void |
set(GRB.StringAttr attr,
GRBVar[] vars,
String[] newvals)
Set a String-valued variable attribute for an array of variables.
|
void |
set(GRB.StringAttr attr,
GRBVar[] vars,
String[] newvals,
int start,
int len)
Deprecated.
|
void |
set(GRB.StringAttr attr,
String newval)
Set the value of a String-valued model attribute.
|
void |
set(GRB.StringParam param,
String newval)
Set the value of a string-valued parameter.
|
void |
set(String param,
String newval)
Set the value of any parameter using strings alone.
|
void |
setCallback(GRBCallback cb)
Set the callback object for a model.
|
void |
setLogCallback(Consumer<String> logCallback)
Sets a logging callback function to query all output posted by the
model object.
|
void |
setObjective(GRBExpr expr)
Set the model objective.
|
void |
setObjective(GRBExpr expr,
int sense)
Set the model objective, and the objective sense (
GRB.MINIMIZE
for minimization, GRB.MAXIMIZE for maximization). |
void |
setObjectiveN(GRBLinExpr expr,
int index,
int priority,
double weight,
double abstol,
double reltol,
String name)
Set an alternative optimization objective equal to a linear
expression.
|
void |
setPWLObj(GRBVar var,
double[] x,
double[] y)
Set the piecewise-linear objective function for a variable.
|
GRBModel |
singleScenarioModel()
Capture a single scenario from a multi-scenario model.
|
void |
sync()
Wait for a previous asynchronous optimization call to complete.
|
void |
terminate()
Generate a request to terminate the current optimization.
|
void |
tune()
Perform an automated search for parameter settings that improve
performance.
|
void |
update()
Process any pending model modifications.
|
void |
write(String filename) |
public GRBModel(GRBEnv env) throws GRBException
env - Environment for new model.GRBExceptionpublic GRBModel(GRBEnv env, String filename) throws GRBException
.mps, .rew,
.lp, .rlp, .dua, .dlp, .ilp,
or .opb. The files can be compressed, so additional suffixes
of .zip, .gz, .bz2, or .7z are
accepted.env - Environment for new model.filename - Name of the file containing the model.GRBExceptionpublic GRBModel(GRBModel model) throws GRBException
update before copying it.model - Model to copy.GRBExceptionpublic GRBModel(GRBModel model, GRBEnv targetenv) throws GRBException
Note that this method itself is not thread safe, so you should either call it from the main thread or protect access to it with a lock.
Note that pending
updates will not be applied to the model, so you should call javamethod:GRBModel.update before
copying if you would like those to be included in the copy.
For Compute Server users, note that you can copy a model from a client to a Compute Server environment, but it is not possible to copy models from a Compute Server environment to another (client or Compute Server) environment.
model - Model to copy.targetenv - Environment to copy model into.GRBExceptionpublic void dispose()
GRBModel object. While
the Java garbage collector will eventually reclaim these resources, we
recommend that you call the dispose method when you are done
using a model.
You should not attempt to use a GRBModel object after calling
dispose on it.
public void read(String filename) throws GRBException
filename - Name of the file to read. The suffix on the file must be either
.bas (for an LP basis), .mst or .sol
(for a MIP start), .hnt (for MIP hints), .ord
(for a priority order), or .prm (for a parameter file). The
suffix may optionally be followed by .zip, .gz,
.bz2, or .7z.GRBExceptionpublic void write(String filename) throws GRBException
filename - The name of the file to be written. The file type is encoded in the
file name suffix. Valid suffixes are .mps, .rew,
.lp, or .rlp for writing the model itself,
.dua or .dlp for writing the dualized model
(only pure LP), .ilp for writing just the IIS associated
with an infeasible model (see GRBModel.computeIIS for further
information), .sol for writing the solution selected by the
SolutionNumber parameter, .mst for writing a
start vector, .hnt for writing a hint file, .bas
for writing an LP basis, .prm for writing modified
parameter settings, .attr for writing model attributes, or
.json for writing solution information in JSON format. If
your system has compression utilities installed (e.g., 7z or
zip for Windows, and gzip, bzip2, or
unzip for Linux or macOS), then the files can be compressed,
so additional suffixes of .gz, .bz2, or
.7z are accepted.GRBExceptionpublic void sync()
throws GRBException
Calling optimizeasync
returns control to the calling routine immediately. The caller can
perform other computations while optimization proceeds, and can check
on the progress of the optimization by querying various model
attributes. The sync call forces the calling program to wait
until the asynchronous optimization call completes. You must
call sync before the corresponding model object is deleted.
The sync call throws an exception if the optimization itself
ran into any problems. In other words, exceptions thrown by this
method are those that optimize itself would have thrown, had
the original method not been asynchronous.
Note that you need to call sync even if you know that the
asynchronous optimization has already completed.
GRBExceptionpublic GRBModel relax() throws GRBException
GRBExceptionpublic GRBModel fixedModel() throws GRBException
optimize method). In the fixed
model, each integer variable is fixed to the value that variable takes
in the MIP solution. In addition, continuous variables may be fixed to
satisfy SOS or general constraints. The result is a model without any
integrality constraints, SOS constraints, or general constraints.
Note that, while the fixed problem is always a continuous model, it may contain a non-convex quadratic objective or non-convex quadratic constraints. As a result, it may still be solved using the MIP algorithm.
GRBExceptionpublic GRBModel presolve() throws GRBException
Please note that the presolved model computed by this function may be different from the presolved model computed when optimizing the model.
GRBExceptionpublic GRBModel dualize() throws GRBException
GRBExceptionpublic GRBModel feasibility() throws GRBException
GRBExceptionpublic GRBModel linearize() throws GRBException
GRBExceptionpublic GRBModel singleScenarioModel() throws GRBException
The model on which this method is invoked must be a multi-scenario model, and the result will be a single-scenario model.
GRBExceptionpublic double feasRelax(int relaxobjtype,
boolean minrelax,
boolean vrelax,
boolean crelax)
throws GRBException
relaxobjtype - The cost function used when finding the minimum cost relaxation.minrelax - The type of feasibility relaxation to perform.vrelax - Indicates whether variable bounds can be relaxed (with a cost of 1.0
for any violations.crelax - Indicates whether linear constraints can be relaxed (with a cost of
1.0 for any violations.GRBExceptionpublic double feasRelax(int relaxobjtype,
boolean minrelax,
GRBVar[] vars,
double[] lbpen,
double[] ubpen,
GRBConstr[] constrs,
double[] rhspen)
throws GRBException
relaxobjtype - The cost function used when finding the minimum cost relaxation.minrelax - The type of feasibility relaxation to perform.vars - Variables whose bounds are allowed to be violated.lbpen - Penalty for violating a variable lower bound. One entry for each
variable in argument vars.ubpen - Penalty for violating a variable upper bound. One entry for each
variable in argument vars.constrs - Linear constraints that are allowed to be violated.rhspen - Penalty for violating a linear constraint. One entry for each
constraint in argument constrs.GRBExceptionpublic GRBVar getVar(int i)
public GRBVar[] getVars()
public GRBVar getVarByName(String name) throws GRBException
name - The name of the desired variable.GRBExceptionpublic GRBConstr getConstr(int i)
public GRBConstr[] getConstrs()
public GRBConstr getConstrByName(String name) throws GRBException
name - The name of the desired linear constraint.GRBExceptionpublic GRBSOS[] getSOSs()
public GRBQConstr[] getQConstrs()
public GRBGenConstr[] getGenConstrs()
public GRBExpr getObjective() throws GRBException
Note that the constant and linear portions of the objective can also be retrieved using the ObjCon and Obj attributes.
GRBExceptionpublic GRBLinExpr getObjective(int index) throws GRBException
index = 0), but you will get an
exception if the primary objective contains quadratic terms. Please refer to the discussion of Multiple Objectives for more information on the use of alternative objectives.
Note that alternative objectives can also be retrieved using the ObjNCon and ObjN attributes.
index - The index for the requested alternative objective.GRBExceptionpublic int getPWLObj(GRBVar var, double[] x, double[] y) throws GRBException
null values for x and y if you
just want the number of points.
Refer to this discussion for additional information on what the values in x and y mean.
var - The variable whose objective function is being retrieved.x - The x values for the points that define the piecewise-linear function.
These will always be in non-decreasing order.y - The y values for the points that define the piecewise-linear function.GRBExceptionpublic void setObjective(GRBExpr expr) throws GRBException
expr - New model objective.GRBExceptionpublic void setObjective(GRBExpr expr, int sense) throws GRBException
GRB.MINIMIZE
for minimization, GRB.MAXIMIZE for maximization).expr - New model objective.sense - New optimization sense (GRB.MINIMIZE for minimization,
GRB.MAXIMIZE for maximization).GRBExceptionpublic void setObjectiveN(GRBLinExpr expr, int index, int priority, double weight, double abstol, double reltol, String name) throws GRBException
Please refer to the discussion of Multiple Objectives for more information on the use of alternative objectives.
Note
that you can also modify an alternative objective using the ObjN variable attribute. If you wish to mix and match these two
approaches, please note that this method replaces the entire existing
objective, while the ObjN attribute can be used to modify
individual terms.
expr - New alternative objective.index - Index for new objective. If you use an index of 0, this routine will
change the primary optimization objective.priority - Priority for the alternative objective. This initializes the ObjNPriority attribute for this objective.weight - Weight for the alternative objective. This initializes the ObjNWeight attribute for this objective.abstol - Absolute tolerance for the alternative objective. This initializes the
ObjNAbsTol attribute for this objective.reltol - Relative tolerance for the alternative objective. This initializes the
ObjNRelTol attribute for this objective.name - Name of the alternative objective. This initializes the ObjNName attribute for this objective.GRBExceptionpublic void setPWLObj(GRBVar var, double[] x, double[] y) throws GRBException
var - The variable whose objective function is being set.x - The x values for the points that define the piecewise-linear function.
Must be in non-decreasing order.y - The y values for the points that define the piecewise-linear function.GRBExceptionpublic void optimize()
throws GRBException
Please consult this section in the Reference Manual for a discussion of some of the practical issues associated with solving a precisely defined mathematical model using finite-precision floating-point arithmetic.
Note that this method will process all pending model modifications.
GRBExceptionpublic void optimizeasync()
throws GRBException
IN_PROGRESS indicates that the optimization has not
yet completed. When you are done with your foreground tasks, you must
call sync to sync your
foreground program with the asynchronous optimization task.
Note that the set of Gurobi calls that you are allowed to make while
optimization is running in the background is severely limited.
Specifically, you can only perform attribute queries, and only for a
few attributes (listed below). Any other calls on the running model,
or on any other models that were built within the same Gurobi
environment, will fail with error code OPTIMIZATION_IN_PROGRESS.
Note that there are no such restrictions on models built in other environments. Thus, for example, you could create multiple environments, and then have a single foreground program launch multiple simultaneous asynchronous optimizations, each in its own environment.
As already noted, you are allowed to query the value of the Status attribute while an asynchronous optimization is in progress.
The other attributes that can be queried are: ObjVal,
ObjBound, IterCount, NodeCount, and
BarIterCount. In each case, the returned value reflects
progress in the optimization to that point. Any attempt to query the
value of an attribute not on this list will return an OPTIMIZATION_IN_PROGRESS error.
GRBExceptionpublic String optimizeBatch() throws GRBException
GRBExceptionpublic void convertToFixed()
throws GRBException
GRBExceptionpublic void computeIIS()
throws GRBException
Note that an infeasible model may have multiple IISs. The one returned by Gurobi is not necessarily the smallest one; there may exist others with fewer constraints or bounds.
IIS results are returned in a number of attributes: IISConstr, IISLB, IISUB, IISSOS, IISQConstr, and IISGenConstr. Each indicates whether the corresponding model element is a member of the computed IIS.
Note that for models with general function constraints, piecewise- linear approximation of the constraints may cause unreliable IIS results.
The IIS log provides information about the progress of the algorithm, including a guess at the eventual IIS size.
If an IIS computation is interrupted before completion, Gurobi will return the smallest infeasible subsystem found to that point.
The IISConstrForce, IISLBForce, IISUBForce, IISSOSForce, IISQConstrForce, and IISGenConstrForce attributes allow you mark model elements to either include or exclude from the computed IIS. Setting the attribute to 1 forces the corresponding element into the IIS, setting it to 0 forces it out of the IIS, and setting it to -1 allows the algorithm to decide.
To give an example of when these attributes might be useful, consider the case where an initial model is known to be feasible, but it becomes infeasible after adding constraints or tightening bounds. If you are only interested in knowing which of the changes caused the infeasibility, you can force the unmodified bounds and constraints into the IIS. That allows the IIS algorithm to focus exclusively on the new constraints, which will often be substantially faster.
Note that setting any of the Force attributes to 0 may make
the resulting subsystem feasible, which would then make it impossible
to construct an IIS. Trying anyway will result in a GRB_ERROR_IIS_NOT_INFEASIBLE error. Similarly, setting this attribute
to 1 may result in an IIS that is not irreducible. More precisely, the
system would only be irreducible with respect to the model elements
that have force values of -1 or 0.
This method populates the IISConstr, IISQConstr,
and IISGenConstr constraint attributes, the IISSOS, SOS attribute, and the IISLB and IISUB
variable attributes. You can also obtain information about the results
of the IIS computation by writing a .ilp format file (see
GRBModel.write). This file
contains only the IIS from the original model.
Use the IISMethod parameter to adjust the behavior of the IIS algorithm.
Note that this method can be used to compute IISs for both continuous and MIP models.
GRBExceptionpublic void tune()
throws GRBException
getTuneResult.
Please refer to the Parameter Tuning section in the Reference Manual for details on the tuning tool.
GRBExceptionpublic void getTuneResult(int i)
throws GRBException
tune call. Calling this method with
argument n causes tuned parameter set n to be copied
into the model. Parameter sets are stored in order of decreasing
quality, with parameter set 0 being the best. The number of available
sets is stored in attribute TuneResultCount.
Once you have retrieved a tuning result, you can call optimize to use these parameter
settings to optimize the model, or write to write the changed
parameters to a .prm file.
Please refer to the Parameter Tuning section in the Reference Manual for details on the tuning tool.
i - The index of the tuning result to retrieve. The best result is
available as index 0. The number of stored results is available in
attribute TuneResultCount.GRBExceptionpublic void reset()
throws GRBException
GRBExceptionpublic void reset(int clearall)
throws GRBException
clearall - A value of 1 discards additional information that affects the solution
process but not the actual model (currently MIP starts, variable
hints, branching priorities, lazy flags, and partition information).
Pass 0 to just discard the solution.GRBExceptionpublic void check()
throws GRBException
GRBExceptionpublic void terminate()
When the optimization stops, the Status attribute will be
equal to GRB_INTERRUPTED.
public void update()
throws GRBException
GRBExceptionpublic GRBVar addVar(double lb, double ub, double obj, char type, String name) throws GRBException
lb - Lower bound for new variable.ub - Upper bound for new variable.obj - Objective coefficient for new variable.type - Variable type for new variable (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT).name - Name for new variable.GRBExceptionpublic GRBVar addVar(double lb, double ub, double obj, char type, GRBConstr[] constrs, double[] coeffs, String name) throws GRBException
lb - Lower bound for new variable.ub - Upper bound for new variable.obj - Objective coefficient for new variable.type - Variable type for new variable (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT).constrs - Array of constraints in which the variable participates.coeffs - Array of coefficients for each constraint in which the variable
participates. The lengths of the constrs and coeffs arrays must be identical.name - Name for new variable.GRBExceptionpublic GRBVar addVar(double lb, double ub, double obj, char type, GRBColumn col, String name) throws GRBException
GRBColumn object.lb - Lower bound for new variable.ub - Upper bound for new variable.obj - Objective coefficient for new variable.type - Variable type for new variable (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT).col - GRBColumn object for specifying a set of constraints to which new
variable belongs.name - Name for new variable.GRBExceptionpublic GRBVar[] addVars(int count, char type) throws GRBException
count new decision variables to a model. All associated
attributes take their default values, except the variable type, which is specified as an argument.count - Number of variables to add.type - Variable type for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT).GRBExceptionpublic GRBVar[] addVars(double[] lb, double[] ub, double[] obj, char[] type, String[] names) throws GRBException
lb - Lower bounds for new variables. Can be null, in which case
the variables get lower bounds of 0.0.ub - Upper bounds for new variables. Can be null, in which case
the variables get infinite upper bounds.obj - Objective coefficients for new variables. Can be null, in
which case the variables get objective coefficients of 0.0.type - Variable types for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT). Can be null, in which case the
variables are assumed to be continuous.names - Names for new variables. Can be null, in which case all
variables are given default names.GRBExceptionpublic GRBVar[] addVars(double[] lb, double[] ub, double[] obj, char[] type, String[] names, int start, int len) throws GRBException
start and len arguments allow you to
specify which variables to add.lb - Lower bounds for new variables. Can be null, in which case
the variables get lower bounds of 0.0.ub - Upper bounds for new variables. Can be null, in which case
the variables get infinite upper bounds.obj - Objective coefficients for new variables. Can be null, in
which case the variables get objective coefficients of 0.0.type - Variable types for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT). Can be null, in which case the
variables are assumed to be continuous.names - Names for new variables. Can be null, in which case all
variables are given default names.start - The first variable in the list to add.len - The number of variables to add.GRBExceptionpublic GRBVar[] addVars(double[] lb, double[] ub, double[] obj, char[] type, String[] names, GRBColumn[] cols) throws GRBException
GRBColumn
objects.lb - Lower bounds for new variables. Can be null, in which case
the variables get lower bounds of 0.0.ub - Upper bounds for new variables. Can be null, in which case
the variables get infinite upper bounds.obj - Objective coefficients for new variables. Can be null, in
which case the variables get objective coefficients of 0.0.type - Variable types for new variables (GRB.CONTINUOUS, GRB.BINARY, GRB.INTEGER, GRB.SEMICONT, or
GRB.SEMIINT). Can be null, in which case the
variables are assumed to be continuous.names - Names for new variables. Can be null, in which case all
variables are given default names.cols - GRBColumn objects for specifying a set of constraints to which each
new column belongs.GRBExceptionpublic GRBConstr addConstr(GRBLinExpr lhsExpr, char sense, GRBLinExpr rhsExpr, String name) throws GRBException
lhsExpr - Left-hand side expression for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side expression for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(GRBLinExpr lhsExpr, char sense, GRBVar rhsVar, String name) throws GRBException
lhsExpr - Left-hand side expression for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhsVar - Right-hand side variable for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(GRBVar lhsVar, char sense, GRBLinExpr rhsExpr, String name) throws GRBException
lhsVar - Left-hand side variable for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side expression for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(GRBVar lhsVar, char sense, GRBVar rhsVar, String name) throws GRBException
lhsVar - Left-hand side variable for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhsVar - Right-hand side variable for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(GRBVar lhsVar, char sense, double rhs, String name) throws GRBException
lhsVar - Left-hand side variable for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhs - Right-hand side value for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(double lhs, char sense, GRBVar rhsVar, String name) throws GRBException
lhs - Left-hand side value for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhsVar - Right-hand side variable for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(GRBLinExpr lhsExpr, char sense, double rhs, String name) throws GRBException
lhsExpr - Left-hand side expression for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhs - Right-hand side value for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addConstr(double lhs, char sense, GRBLinExpr rhsExpr, String name) throws GRBException
lhs - Left-hand side value for new linear constraint.sense - Sense for new linear constraint (GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side expression for new linear constraint.name - Name for new constraint.GRBExceptionpublic GRBConstr addRange(GRBLinExpr expr, double lower, double upper, String name) throws GRBException
lower and upper bounds in any solution.
Note that range constraints are stored internally as equality
constraints. We add an extra variable to the model to capture the
range information. Thus, the Sense attribute on a range
constraint will always be GRB.EQUAL. In particular introducing
a range constraint
is equivalent to adding a slack variable s and the following constraints
expr - Linear expression for new range constraint.lower - Lower bound for linear expression.upper - Upper bound for linear expression.name - Name for new constraint.GRBExceptionpublic GRBConstr[] addConstrs(int count) throws GRBException
count new linear constraints to a model. The new
constraints are all of the form 0 <= 0.count - Number of constraints to add.GRBExceptionpublic GRBConstr[] addConstrs(GRBLinExpr[] lhsExprs, char[] senses, double[] rhss, String[] names) throws GRBException
lhsExprs - Left-hand side expressions for the new linear constraints.senses - Senses for new linear constraints (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhss - Right-hand side values for the new linear constraints.names - Names for new constraints.GRBExceptionpublic GRBConstr[] addConstrs(GRBLinExpr[] lhsExprs, char[] senses, double[] rhss, String[] names, int start, int len) throws GRBException
start and len arguments allow you to
specify which constraints to add.lhsExprs - Left-hand side expressions for the new linear constraints.senses - Senses for new linear constraints (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhss - Right-hand side values for the new linear constraints.names - Names for new constraints.start - The first constraint in the list to add.len - The number of constraints to add.GRBExceptionpublic GRBConstr[] addRanges(GRBLinExpr[] exprs, double[] lower, double[] upper, String[] names) throws GRBException
lower and upper bounds in any solution.exprs - Linear expressions for the new range constraints.lower - Lower bounds for linear expressions.upper - Upper bounds for linear expressions.names - Names for new range constraints.GRBExceptionpublic GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, GRBQuadExpr rhsExpr, String name) throws GRBException
lhsExpr - Left-hand side quadratic expression for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side quadratic expression for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, GRBLinExpr rhsExpr, String name) throws GRBException
lhsExpr - Left-hand side quadratic expression for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side linear expression for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBQConstr addQConstr(GRBLinExpr lhsExpr, char sense, GRBQuadExpr rhsExpr, String name) throws GRBException
lhsExpr - Left-hand side linear expression for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side quadratic expression for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, GRBVar rhsVar, String name) throws GRBException
lhsExpr - Left-hand side quadratic expression for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhsVar - Right-hand side variable for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBQConstr addQConstr(GRBVar lhsVar, char sense, GRBQuadExpr rhsExpr, String name) throws GRBException
lhsVar - Left-hand side variable for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side quadratic expression for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBQConstr addQConstr(GRBQuadExpr lhsExpr, char sense, double rhs, String name) throws GRBException
lhsExpr - Left-hand side quadratic expression for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhs - Right-hand side value for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBQConstr addQConstr(double lhs, char sense, GRBQuadExpr rhsExpr, String name) throws GRBException
lhs - Left-hand side value for new quadratic constraint.sense - Sense for new quadratic constraint (GRB.LESS_EQUAL,
GRB.EQUAL, or GRB.GREATER_EQUAL).rhsExpr - Right-hand side quadratic expression for new quadratic constraint.name - Name for new constraint.GRBExceptionpublic GRBGenConstr addGenConstrMax(GRBVar resvar, GRBVar[] vars, double constant, String name) throws GRBException
A MAX constraint r = max(x1, ..., xn, c) states that the resultant variable r should be equal to the maximum of the operand variables x1, ..., xn and the constant c.
resvar - The resultant variable of the new constraint.vars - Array of variables that are the operands of the new constraint.constant - The additional constant operand of the new constraint.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrMin(GRBVar resvar, GRBVar[] vars, double constant, String name) throws GRBException
A MIN constraint r = min(x1, ...,xn, c) states that the resultant variable r should be equal to the minimum of the operand variables x1, ...,xn and the constant c.
resvar - The resultant variable of the new constraint.vars - Array of variables that are the operands of the new constraint.constant - The additional constant operand of the new constraint.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrAbs(GRBVar resvar, GRBVar argvar, String name) throws GRBException
An ABS constraint r = |x| states that the resultant variable r should be equal to the absolute value of the argument variable x.
resvar - The resultant variable of the new constraint.argvar - The argument variable of the new constraint.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrAnd(GRBVar resvar, GRBVar[] vars, String name) throws GRBException
An AND constraint r = and(x1, ..., xn) states that the binary resultant variable r should be 1 if and only if all of the operand variables x1, ..., xn are equal to 1. If any of the operand variables is 0, then the resultant should be 0 as well.
Note that all variables participating in such a constraint will be forced to be binary, independent of how they were created.
resvar - The resultant variable of the new constraint.vars - Array of variables that are the operands of the new constraint.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrOr(GRBVar resvar, GRBVar[] vars, String name) throws GRBException
An OR constraint r = or(x1, ..., xn) states that the binary resultant variable r should be 1 if and only if any of the operand variables x1, ..., xn is equal to 1. If all operand variables are 0, then the resultant should be 0 as well.
Note that all variables participating in such a constraint will be forced to be binary, independent of how they were created.
resvar - The resultant variable of the new constraint.vars - Array of variables that are the operands of the new constraint.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrNorm(GRBVar resvar, GRBVar[] vars, double which, String name) throws GRBException
A NORM constraint r = norm(x1, ...,xn) states that the resultant variable r should be equal to the vector norm of the argument vector x1, ..., xn .
resvar - The resultant variable of the new constraint.vars - Array of variables that are the operands of the new constraint. Note
that this array may not contain duplicates.which - Which norm to use. Options are 0, 1, 2, and GRB.INFINITY.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrIndicator(GRBVar binvar, int binval, GRBLinExpr expr, char sense, double rhs, String name) throws GRBException
An INDICATOR constraint z = f → a^T x ≤ b states that if the binary indicator variable z is equal to f, where f binary , then the linear constraint a^T x ≤ b should hold. On the other hand, if z = 1-f , the linear constraint may be violated. The sense of the linear constraint can also be specified to be = or ≤ .
Note that the indicator variable z of a constraint will be forced to be binary, independent of how it was created.
binvar - The binary indicator variable.binval - The value for the binary indicator variable that would force the
linear constraint to be satisfied (0 or 1).expr - Left-hand side expression for the linear constraint triggered by the
indicator.sense - Sense for the linear constraint. Options are GRB.LESS_EQUAL, GRB.EQUAL, or GRB.GREATER_EQUAL.rhs - Right-hand side value for the linear constraint.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrPWL(GRBVar xvar, GRBVar yvar, double[] xpts, double[] ypts, String name) throws GRBException
A piecewise-linear (PWL) constraint states that the relationship y = f(x) must hold between variables x and y, where f is a piecewise- linear function. The breakpoints for f are provided as arguments. Refer to the description of piecewise-linear objectives for details of how piecewise-linear functions are defined.
xvar - The x variable.yvar - The y variable.xpts - The x values for the points that define the piecewise-linear function.
Must be in non-decreasing order.ypts - The y values for the points that define the piecewise-linear function.name - Name for the new general constraint.GRBExceptionpublic GRBGenConstr addGenConstrPoly(GRBVar xvar, GRBVar yvar, double[] p, String name, String options) throws GRBException
A polynomial function constraint states that the relationship y = p(0) x^d + p(1) x^(d-1) + ... + p(d-1) x + p(d) should hold between variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.p - The coefficients for the polynomial function (starting with the
coefficient for the highest power).name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrExp(GRBVar xvar, GRBVar yvar, String name, String options) throws GRBException
A natural exponential function constraint states that the relationship y = exp(x) should hold for variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrExpA(GRBVar xvar, GRBVar yvar, double a, String name, String options) throws GRBException
An exponential function constraint states that the relationship y = a^x should hold for variables x and y, where a > 0 is the (constant) base.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.a - The base of the function, a > 0 .name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrLog(GRBVar xvar, GRBVar yvar, String name, String options) throws GRBException
A natural logarithmic function constraint states that the relationship y = log(x) should hold for variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrLogA(GRBVar xvar, GRBVar yvar, double a, String name, String options) throws GRBException
A logarithmic function constraint states that the relationship y = log(a, x) should hold for variables x and y, where a > 0 is the (constant) base.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.a - The base of the function, a > 0 .name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrPow(GRBVar xvar, GRBVar yvar, double a, String name, String options) throws GRBException
A power function constraint states that the relationship y = x^a should hold for variables x and y, where a is the (constant) exponent.
If the exponent a is negative, the lower bound on x must be strictly positive. If the exponent isn't an integer, the lower bound on x must be non-negative.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.a - The exponent of the function.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrSin(GRBVar xvar, GRBVar yvar, String name, String options) throws GRBException
A sine function constraint states that the relationship y = sin(x) should hold for variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrCos(GRBVar xvar, GRBVar yvar, String name, String options) throws GRBException
A cosine function constraint states that the relationship y = cos(x) should hold for variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrTan(GRBVar xvar, GRBVar yvar, String name, String options) throws GRBException
A tangent function constraint states that the relationship y = tan(x) should hold for variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrLogistic(GRBVar xvar, GRBVar yvar, String name, String options) throws GRBException
A logistic function constraint states that the relationship y = 1/(1 + e^(-x)) should hold for variables x and y.
A piecewise-linear approximation of the function is added to the model. The details of the approximation are controlled using the following four attributes (or using the parameters with the same names): FuncPieces, FuncPieceError, FuncPieceLength, and FuncPieceRatio. Alternatively, the function can be treated as a nonlinear constraint by setting the attribute FuncNonlinear. For details, consult the General Constraint discussion.
xvar - The x variable.yvar - The y variable.name - Name for the new general constraint.options - A string that can be used to set the attributes that control the
piecewise-linear approximation of this function constraint. To assign
a value to an attribute, follow the attribute name with an equal sign
and the desired value (with no spaces). Assignments for different
attributes should be separated by spaces (e.g. "FuncPieces=-1
FuncPieceError=0.001").GRBExceptionpublic GRBGenConstr addGenConstrNL(GRBVar yvar, int[] opcode, double[] data, int[] parent, String name) throws GRBException
GRBExceptionpublic void remove(GRBVar var) throws GRBException
GRBModel.update), optimize the model (using GRBModel.optimize), or write the
model to disk (using GRBModel.write).var - The variable to remove.GRBExceptionpublic void remove(GRBConstr constr) throws GRBException
GRBModel.update), optimize the model (using GRBModel.optimize), or write the
model to disk (using GRBModel.write).constr - The linear constraint to remove.GRBExceptionpublic void chgCoeff(GRBConstr constr, GRBVar var, double newval) throws GRBException
GRBVar object, a GRBConstr object, and a desired
coefficient for the specified variable in the specified constraint. If
you make multiple changes to the same coefficient, the last one will
be applied.
Note that, due to our lazy update approach, the change won't actually
take effect until you update the model (using GRBModel.update), optimize the
model (using GRBModel.optimize), or write the model to disk (using GRBModel.write).
constr - Constraint for coefficient to be changed.var - Variable for coefficient to be changed.newval - Desired new value for coefficient.GRBExceptionpublic void chgCoeffs(GRBConstr[] constrs, GRBVar[] vars, double[] newvals) throws GRBException
GRBVar object, a GRBConstr object,
and a desired coefficient for the specified variable in the specified
constraint. The entries in the input arrays each correspond to a
single desired coefficient change. The lengths of the input arrays
must all be the same. If you make multiple changes to the same
coefficient, the last one will be applied.
Note that, due to our lazy update approach, the change won't actually
take effect until you update the model (using GRBModel.update), optimize the
model (using GRBModel.optimize), or write the model to disk (using GRBModel.write).
constrs - Constraints for coefficients to be changed.vars - Variables for coefficients to be changed.newvals - Desired new values for coefficients.GRBExceptionpublic double getCoeff(GRBConstr constr, GRBVar var) throws GRBException
var in linear constraint
constr (note that the result can be zero).constr - The requested constraint.var - The requested variable.GRBExceptionpublic GRBColumn getCol(GRBVar var) throws GRBException
GRBColumn object.var - The variable of interest.GRBColumn object that captures
the set of constraints in which the variable participates.GRBExceptionpublic GRBLinExpr getRow(GRBConstr constr) throws GRBException
GRBLinExpr object.constr - The constraint of interest. A GRBConstr object, typically obtained from addConstr or getConstrs.GRBLinExpr object that captures
the set of variables that participate in the constraint.GRBExceptionpublic GRBSOS addSOS(GRBVar[] vars, double[] weights, int type) throws GRBException
vars - Array of variables that participate in the SOS constraint.weights - Weights for the variables in the SOS constraint.type - SOS type (can be GRB.SOS_TYPE1 or GRB.SOS_TYPE2).GRBExceptionpublic int getSOS(GRBSOS sos, GRBVar[] vars, double[] weights, int[] type) throws GRBException
null array
arguments to determine the appropriate array lengths.sos - The SOS set of interest.vars - A list of variables that participate in sos. Can be
null.weights - The SOS weights for each participating variable. Can be null.type - The type of the SOS set (either GRB.SOS_TYPE1 or GRB.SOS_TYPE2) is returned in type[0].GRBExceptionpublic void getGenConstrMax(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len, double[] constant) throws GRBException
genc - The general constraint object.resvar - Store the resultant variable of the constraint at resvar[0].vars - Array to store the operand variables of the constraint.len - Store the number of operand variables of the constraint at len[0].constant - Store the additional constant operand of the constraint at constant[0].GRBExceptionpublic void getGenConstrMin(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len, double[] constant) throws GRBException
genc - The general constraint object.resvar - Store the resultant variable of the constraint at resvar[0].vars - Array to store the operand variables of the constraint.len - Store the number of operand variables of the constraint at len[0].constant - Store the additional constant operand of the constraint at constant[0].GRBExceptionpublic void getGenConstrAbs(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] argvar) throws GRBException
genc - The general constraint object.resvar - Store the resultant variable of the constraint at resvar[0].argvar - Store the argument variable of the constraint at resvar[0].GRBExceptionpublic void getGenConstrAnd(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len) throws GRBException
genc - The general constraint object.resvar - Store the resultant variable of the constraint at resvar[0].vars - Array to store the operand variables of the constraint.len - Store the number of operand variables of the constraint at len[0].GRBExceptionpublic void getGenConstrOr(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len) throws GRBException
genc - The general constraint object.resvar - Store the resultant variable of the constraint at resvar[0].vars - Array to store the operand variables of the constraint.len - Store the number of operand variables of the constraint at len[0].GRBExceptionpublic void getGenConstrNorm(GRBGenConstr genc, GRBVar[] resvar, GRBVar[] vars, int[] len, double[] which) throws GRBException
genc - The general constraint object.resvar - Store the resultant variable of the constraint at resvar[0].vars - Array to store the operand variables of the constraint.len - Store the number of operand variables of the constraint at len[0].which - Store the norm type (possible values are 0, 1, 2, or GRB.INFINITY).GRBExceptionpublic void getGenConstrIndicator(GRBGenConstr genc, GRBVar[] binvar, int[] binval, GRBLinExpr[] expr, char[] sense, double[] rhs) throws GRBException
genc - The general constraint object.binvar - Store the binary indicator variable of the constraint at binvar[0].binval - Store the value that the indicator variable has to take in order to
trigger the linear constraint at binval[0].expr - Create a GRBLinExpr object to
store the left-hand side expression of the linear constraint that is
triggered by the indicator at expr[0].sense - Store the sense for the linear constraint at sense[0].
Options are GRB.LESS_EQUAL, GRB.EQUAL, or
GRB.GREATER_EQUAL.rhs - Store the right-hand side value for the linear constraint at rhs[0].GRBExceptionpublic void getGenConstrPWL(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, int[] npts, double[] xpts, double[] ypts) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.npts - Store the number of points that define the piecewise-linear function.xpts - The x values for the points that define the piecewise-linear function.ypts - The y values for the points that define the piecewise-linear function.GRBExceptionpublic void getGenConstrPoly(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, int[] plen, double[] p) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.plen - Store the array length for p. If x^d is the highest power term, then
d+1 will be returned.p - The coefficients for polynomial function.GRBExceptionpublic void getGenConstrExp(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.GRBExceptionpublic void getGenConstrExpA(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, double[] a) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.a - Store the base of the function.GRBExceptionpublic void getGenConstrLog(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.GRBExceptionpublic void getGenConstrLogA(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, double[] a) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.a - Store the base of the function.GRBExceptionpublic void getGenConstrPow(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar, double[] a) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.a - Store the exponent of the function.GRBExceptionpublic void getGenConstrSin(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.GRBExceptionpublic void getGenConstrCos(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.GRBExceptionpublic void getGenConstrTan(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.GRBExceptionpublic void getGenConstrLogistic(GRBGenConstr genc, GRBVar[] xvar, GRBVar[] yvar) throws GRBException
genc - The general constraint object.xvar - Store the x variable.yvar - Store the y variable.GRBExceptionpublic void getGenConstrNL(GRBGenConstr genc, GRBVar[] yvar, int[] nnodes, int[] opcode, double[] data, int[] parent) throws GRBException
GRBExceptionpublic GRBQuadExpr getQCRow(GRBQConstr qc) throws GRBException
GRBQuadExpr object.qc - The quadratic constraint of interest.GRBQuadExpr object that
captures the left-hand side of the quadratic constraint.GRBExceptionpublic void remove(GRBSOS sos) throws GRBException
GRBModel.update), optimize the model (using GRBModel.optimize), or write the
model to disk (using GRBModel.write).sos - The SOS constraint to remove.GRBExceptionpublic void remove(GRBQConstr qconstr) throws GRBException
GRBModel.update), optimize the model (using GRBModel.optimize), or write the
model to disk (using GRBModel.write).qconstr - The quadratic constraint to remove.GRBExceptionpublic void remove(GRBGenConstr genconstr) throws GRBException
GRBModel.update), optimize the model (using GRBModel.optimize), or write the
model to disk (using GRBModel.write).genconstr - The general constraint to remove.GRBExceptionpublic GRBEnv getEnv() throws GRBException
GRBExceptionpublic GRBEnv getConcurrentEnv(int num) throws GRBException
This method provides fine-grained control over the concurrent
optimizer. By creating your own concurrent environments and setting
appropriate parameters on these environments (e.g., the Method parameter), you can control exactly which strategies the
concurrent optimizer employs. For example, if you create two
concurrent environments, and set Method to primal simplex for
one and dual simplex for the other, subsequent concurrent optimizer
runs will use the two simplex algorithms rather than the default
choices.
Note that you must create contiguously numbered concurrent
environments, starting with num=0. For example, if you want
three concurrent environments, they must be numbered 0, 1, and 2.
Once you create concurrent environments, they will be used for every
subsequent concurrent optimization on that model. Use discardConcurrentEnvs to revert back to default concurrent optimizer
behavior.
num - The concurrent environment number.GRBExceptionpublic void discardConcurrentEnvs()
throws GRBException
The concurrent environments created by getConcurrentEnv will be
used by every subsequent call to the concurrent optimizer until the
concurrent environments are discarded.
Use getMultiobjEnv
to create a multi-objective environment.
GRBExceptionpublic String getJSONSolution() throws GRBException
GRBExceptionpublic GRBEnv getMultiobjEnv(int index) throws GRBException
discardMultiobjEnvs to discard multi-objective environments and
return to standard behavior.index - The optimization pass index, starting from 0.GRBExceptionpublic void discardMultiobjEnvs()
throws GRBException
getMultiobjEnv
to create a multi-objective environments.GRBExceptionpublic int get(GRB.IntParam param) throws GRBException
param - The parameter being queried.GRBExceptionpublic double get(GRB.DoubleParam param) throws GRBException
param - The parameter being queried.GRBExceptionpublic String get(GRB.StringParam param) throws GRBException
param - The parameter being queried.GRBExceptionpublic void set(GRB.IntParam param, int newval) throws GRBException
The difference between
setting a parameter on a model and setting it on an environment (i.e.,
through GRBEnv.set) is that the
former modifies the parameter for a single model, while the latter
modifies the parameter for every model that is subsequently built
using that environment (and leaves the parameter unchanged for models
that were previously built using that environment).
param - The parameter being modified.newval - The desired new value for the parameter.GRBExceptionpublic void set(GRB.DoubleParam param, double newval) throws GRBException
The difference between
setting a parameter on a model and setting it on an environment (i.e.,
through GRBEnv.set) is that the
former modifies the parameter for a single model, while the latter
modifies the parameter for every model that is subsequently built
using that environment (and leaves the parameter unchanged for models
that were previously built using that environment).
param - The parameter being modified.newval - The desired new value for the parameter.GRBExceptionpublic void set(GRB.StringParam param, String newval) throws GRBException
The difference between
setting a parameter on a model and setting it on an environment (i.e.,
through GRBEnv.set) is that the
former modifies the parameter for a single model, while the latter
modifies the parameter for every model that is subsequently built
using that environment (and leaves the parameter unchanged for models
that were previously built using that environment).
param - The parameter being modified.newval - The desired new value for the parameter.GRBExceptionpublic void set(String param, String newval) throws GRBException
The difference
between setting a parameter on a model and setting it on an
environment (i.e., through GRBEnv.set) is that the former modifies the parameter for a single
model, while the latter modifies the parameter for every model that is
subsequently built using that environment (and leaves the parameter
unchanged for models that were previously built using that
environment).
param - The name of the parameter being modified.newval - The desired new value for the parameter.GRBExceptionpublic int get(GRB.IntAttr attr) throws GRBException
attr - The attribute being queried.GRBExceptionpublic double get(GRB.DoubleAttr attr) throws GRBException
attr - The attribute being queried.GRBExceptionpublic String get(GRB.StringAttr attr) throws GRBException
attr - The attribute being queried.GRBExceptionpublic void set(GRB.IntAttr attr, int newval) throws GRBException
attr - The attribute being modified.newval - The desired new value for the attribute.GRBExceptionpublic void set(GRB.DoubleAttr attr, double newval) throws GRBException
attr - The attribute being modified.newval - The desired new value for the attribute.GRBExceptionpublic void set(GRB.StringAttr attr, String newval) throws GRBException
attr - The attribute being modified.newval - The desired new value for the attribute.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBVar[] vars) throws GRBException
attr - The attribute being queried.vars - The variables whose attribute values are being queried.GRBExceptionpublic char[] get(GRB.CharAttr attr, GRBVar[] vars) throws GRBException
attr - The attribute being queried.vars - The variables whose attribute values are being queried.GRBExceptionpublic double[] get(GRB.DoubleAttr attr, GRBVar[] vars) throws GRBException
attr - The attribute being queried.vars - The variables whose attribute values are being queried.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBVar[] vars) throws GRBException
attr - The attribute being queried.vars - The variables whose attribute values are being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBVar[] vars, int start, int len) throws GRBException
attr - The attribute being queried.vars - A one-dimensional array of variables whose attribute values are being
queried.start - The index of the first variable of interest in the list.len - The number of variables.GRBExceptionpublic char[] get(GRB.CharAttr attr, GRBVar[] vars, int start, int len) throws GRBException
attr - The attribute being queried.vars - A one-dimensional array of variables whose attribute values are being
queried.start - The index of the first variable of interest in the list.len - The number of variables.GRBExceptionpublic double[] get(GRB.DoubleAttr attr, GRBVar[] vars, int start, int len) throws GRBException
attr - The attribute being queried.vars - A one-dimensional array of variables whose attribute values are being
queried.start - The index of the first variable of interest in the list.len - The number of variables.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBVar[] vars, int start, int len) throws GRBException
attr - The attribute being queried.vars - A one-dimensional array of variables whose attribute values are being
queried.start - The index of the first variable of interest in the list.len - The number of variables.GRBExceptionpublic int[][] get(GRB.IntAttr attr, GRBVar[][] vars) throws GRBException
attr - The attribute being queried.vars - A two-dimensional array of variables whose attribute values are being
queried.GRBExceptionpublic char[][] get(GRB.CharAttr attr, GRBVar[][] vars) throws GRBException
attr - The attribute being queried.vars - A two-dimensional array of variables whose attribute values are being
queried.GRBExceptionpublic double[][] get(GRB.DoubleAttr attr, GRBVar[][] vars) throws GRBException
attr - The attribute being queried.vars - A two-dimensional array of variables whose attribute values are being
queried.GRBExceptionpublic String[][] get(GRB.StringAttr attr, GRBVar[][] vars) throws GRBException
attr - The attribute being queried.vars - A two-dimensional array of variables whose attribute values are being
queried.GRBExceptionpublic int[][][] get(GRB.IntAttr attr, GRBVar[][][] vars) throws GRBException
attr - The attribute being queried.vars - A three-dimensional array of variables whose attribute values are
being queried.GRBExceptionpublic char[][][] get(GRB.CharAttr attr, GRBVar[][][] vars) throws GRBException
attr - The attribute being queried.vars - A three-dimensional array of variables whose attribute values are
being queried.GRBExceptionpublic double[][][] get(GRB.DoubleAttr attr, GRBVar[][][] vars) throws GRBException
attr - The attribute being queried.vars - A three-dimensional array of variables whose attribute values are
being queried.GRBExceptionpublic String[][][] get(GRB.StringAttr attr, GRBVar[][][] vars) throws GRBException
attr - The attribute being queried.vars - A three-dimensional array of variables whose attribute values are
being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBConstr[] constrs) throws GRBException
attr - The attribute being queried.constrs - The constraints whose attribute values are being queried.GRBExceptionpublic char[] get(GRB.CharAttr attr, GRBConstr[] constrs) throws GRBException
attr - The attribute being queried.constrs - The constraints whose attribute values are being queried.GRBExceptionpublic double[] get(GRB.DoubleAttr attr, GRBConstr[] constrs) throws GRBException
attr - The attribute being queried.constrs - The constraints whose attribute values are being queried.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBConstr[] constrs) throws GRBException
attr - The attribute being queried.constrs - The constraints whose attribute values are being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBConstr[] constrs, int start, int len) throws GRBException
attr - The attribute being queried.constrs - A one-dimensional array of constraints whose attribute values are
being queried.start - The index of the first constraint of interest in the list.len - The number of constraints.GRBExceptionpublic char[] get(GRB.CharAttr attr, GRBConstr[] constrs, int start, int len) throws GRBException
attr - The attribute being queried.constrs - A one-dimensional array of constraints whose attribute values are
being queried.start - The index of the first constraint of interest in the list.len - The number of constraints.GRBExceptionpublic double[] get(GRB.DoubleAttr attr, GRBConstr[] constrs, int start, int len) throws GRBException
attr - The attribute being queried.constrs - A one-dimensional array of constraints whose attribute values are
being queried.start - The first constraint of interest in the list.len - The number of constraints.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBConstr[] constrs, int start, int len) throws GRBException
attr - The attribute being queried.constrs - A one-dimensional array of constraints whose attribute values are
being queried.start - The index of the first constraint of interest in the list.len - The number of constraints.GRBExceptionpublic int[][] get(GRB.IntAttr attr, GRBConstr[][] constrs) throws GRBException
attr - The attribute being queried.constrs - A two-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic char[][] get(GRB.CharAttr attr, GRBConstr[][] constrs) throws GRBException
attr - The attribute being queried.constrs - A two-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic double[][] get(GRB.DoubleAttr attr, GRBConstr[][] constrs) throws GRBException
attr - The attribute being queried.constrs - A two-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic String[][] get(GRB.StringAttr attr, GRBConstr[][] constrs) throws GRBException
attr - The attribute being queried.constrs - A two-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic int[][][] get(GRB.IntAttr attr, GRBConstr[][][] constrs) throws GRBException
attr - The attribute being queried.constrs - A three-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic char[][][] get(GRB.CharAttr attr, GRBConstr[][][] constrs) throws GRBException
attr - The attribute being queried.constrs - A three-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic double[][][] get(GRB.DoubleAttr attr, GRBConstr[][][] constrs) throws GRBException
attr - The attribute being queried.constrs - A three-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic String[][][] get(GRB.StringAttr attr, GRBConstr[][][] constrs) throws GRBException
attr - The attribute being queried.constrs - A three-dimensional array of constraints whose attribute values are
being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBQConstr[] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - The quadratic constraints whose attribute values are being queried.GRBExceptionpublic char[] get(GRB.CharAttr attr, GRBQConstr[] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - The quadratic constraints whose attribute values are being queried.GRBExceptionpublic double[] get(GRB.DoubleAttr attr, GRBQConstr[] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - The quadratic constraints whose attribute values are being queried.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBQConstr[] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - The quadratic constraints whose attribute values are being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBQConstr[] qconstrs, int start, int len) throws GRBException
attr - The attribute being queried.qconstrs - A one-dimensional array of quadratic constraints whose attribute
values are being queried.start - The index of the first quadratic constraint of interest in the list.len - The number of quadratic constraints.GRBExceptionpublic char[] get(GRB.CharAttr attr, GRBQConstr[] qconstrs, int start, int len) throws GRBException
attr - The attribute being queried.qconstrs - A one-dimensional array of quadratic constraints whose attribute
values are being queried.start - The index of the first quadratic constraint of interest in the list.len - The number of quadratic constraints.GRBExceptionpublic double[] get(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, int start, int len) throws GRBException
attr - The attribute being queried.qconstrs - A one-dimensional array of quadratic constraints whose attribute
values are being queried.start - The first quadratic constraint of interest in the list.len - The number of quadratic constraints.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBQConstr[] qconstrs, int start, int len) throws GRBException
attr - The attribute being queried.qconstrs - A one-dimensional array of quadratic constraints whose attribute
values are being queried.start - The index of the first quadratic constraint of interest in the list.len - The number of quadratic constraints.GRBExceptionpublic int[][] get(GRB.IntAttr attr, GRBQConstr[][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic char[][] get(GRB.CharAttr attr, GRBQConstr[][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic double[][] get(GRB.DoubleAttr attr, GRBQConstr[][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic String[][] get(GRB.StringAttr attr, GRBQConstr[][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic int[][][] get(GRB.IntAttr attr, GRBQConstr[][][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic char[][][] get(GRB.CharAttr attr, GRBQConstr[][][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic double[][][] get(GRB.DoubleAttr attr, GRBQConstr[][][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic String[][][] get(GRB.StringAttr attr, GRBQConstr[][][] qconstrs) throws GRBException
attr - The attribute being queried.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBGenConstr[] genconstrs) throws GRBException
attr - The attribute being queried.genconstrs - The general constraints whose attribute values are being queried.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBGenConstr[] genconstrs) throws GRBException
attr - The attribute being queried.genconstrs - The general constraints whose attribute values are being queried.GRBExceptionpublic int[] get(GRB.IntAttr attr, GRBGenConstr[] genconstrs, int start, int len) throws GRBException
attr - The attribute being queried.genconstrs - A one-dimensional array of general constraints whose attribute values
are being queried.start - The index of the first general constraint of interest in the list.len - The number of general constraints.GRBExceptionpublic String[] get(GRB.StringAttr attr, GRBGenConstr[] genconstrs, int start, int len) throws GRBException
attr - The attribute being queried.genconstrs - A one-dimensional array of general constraints whose attribute values
are being queried.start - The index of the first general constraint of interest in the list.len - The number of general constraints.GRBExceptionpublic int[][] get(GRB.IntAttr attr, GRBGenConstr[][] genconstrs) throws GRBException
attr - The attribute being queried.genconstrs - A two-dimensional array of general constraints whose attribute values
are being queried.GRBExceptionpublic String[][] get(GRB.StringAttr attr, GRBGenConstr[][] genconstrs) throws GRBException
attr - The attribute being queried.genconstrs - A two-dimensional array of general constraints whose attribute values
are being queried.GRBExceptionpublic int[][][] get(GRB.IntAttr attr, GRBGenConstr[][][] genconstrs) throws GRBException
attr - The attribute being queried.genconstrs - A three-dimensional array of general constraints whose attribute
values are being queried.GRBExceptionpublic String[][][] get(GRB.StringAttr attr, GRBGenConstr[][][] genconstrs) throws GRBException
attr - The attribute being queried.genconstrs - A three-dimensional array of general constraints whose attribute
values are being queried.GRBExceptionpublic void set(GRB.IntAttr attr, GRBVar[] vars, int[] newvals) throws GRBException
attr - The attribute being modified.vars - The variables whose attribute values are being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.CharAttr attr, GRBVar[] vars, char[] newvals) throws GRBException
attr - The attribute being modified.vars - The variables whose attribute values are being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBVar[] vars, double[] newvals) throws GRBException
attr - The attribute being modified.vars - The variables whose attribute values are being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.StringAttr attr, GRBVar[] vars, String[] newvals) throws GRBException
attr - The attribute being modified.vars - The variables whose attribute values are being modified.newvals - The desired new values for the attribute for each input variable.GRBException@Deprecated public void set(GRB.IntAttr attr, GRBVar[] vars, int[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.CharAttr attr, GRBVar[] vars, char[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.DoubleAttr attr, GRBVar[] vars, double[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.StringAttr attr, GRBVar[] vars, String[] newvals, int start, int len) throws GRBException
GRBExceptionpublic void set(GRB.IntAttr attr, GRBVar[][] vars, int[][] newvals) throws GRBException
attr - The attribute being modified.vars - A two-dimensional array of variables whose attribute values are being
modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.CharAttr attr, GRBVar[][] vars, char[][] newvals) throws GRBException
attr - The attribute being modified.vars - A two-dimensional array of variables whose attribute values are being
modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBVar[][] vars, double[][] newvals) throws GRBException
attr - The attribute being modified.vars - A two-dimensional array of variables whose attribute values are being
modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.StringAttr attr, GRBVar[][] vars, String[][] newvals) throws GRBException
attr - The attribute being modified.vars - A two-dimensional array of variables whose attribute values are being
modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.IntAttr attr, GRBVar[][][] vars, int[][][] newvals) throws GRBException
attr - The attribute being modified.vars - A three-dimensional array of variables whose attribute values are
being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.CharAttr attr, GRBVar[][][] vars, char[][][] newvals) throws GRBException
attr - The attribute being modified.vars - A three-dimensional array of variables whose attribute values are
being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBVar[][][] vars, double[][][] newvals) throws GRBException
attr - The attribute being modified.vars - A three-dimensional array of variables whose attribute values are
being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.StringAttr attr, GRBVar[][][] vars, String[][][] newvals) throws GRBException
attr - The attribute being modified.vars - A three-dimensional array of variables whose attribute values are
being modified.newvals - The desired new values for the attribute for each input variable.GRBExceptionpublic void set(GRB.IntAttr attr, GRBConstr[] constrs, int[] newvals) throws GRBException
attr - The attribute being modified.constrs - The constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.CharAttr attr, GRBConstr[] constrs, char[] newvals) throws GRBException
attr - The attribute being modified.constrs - The constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBConstr[] constrs, double[] newvals) throws GRBException
attr - The attribute being modified.constrs - The constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBConstr[] constrs, String[] newvals) throws GRBException
attr - The attribute being modified.constrs - The constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input constraint.GRBException@Deprecated public void set(GRB.IntAttr attr, GRBConstr[] constrs, int[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.CharAttr attr, GRBConstr[] constrs, char[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.DoubleAttr attr, GRBConstr[] constrs, double[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.StringAttr attr, GRBConstr[] constrs, String[] newvals, int start, int len) throws GRBException
GRBExceptionpublic void set(GRB.IntAttr attr, GRBConstr[][] constrs, int[][] newvals) throws GRBException
attr - The attribute being modified.constrs - A two-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.CharAttr attr, GRBConstr[][] constrs, char[][] newvals) throws GRBException
attr - The attribute being modified.constrs - A two-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBConstr[][] constrs, double[][] newvals) throws GRBException
attr - The attribute being modified.constrs - A two-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBConstr[][] constrs, String[][] newvals) throws GRBException
attr - The attribute being modified.constrs - A two-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.IntAttr attr, GRBConstr[][][] constrs, int[][][] newvals) throws GRBException
attr - The attribute being modified.constrs - A three-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.CharAttr attr, GRBConstr[][][] constrs, char[][][] newvals) throws GRBException
attr - The attribute being modified.constrs - A three-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBConstr[][][] constrs, double[][][] newvals) throws GRBException
attr - The attribute being modified.constrs - A three-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBConstr[][][] constrs, String[][][] newvals) throws GRBException
attr - The attribute being modified.constrs - A three-dimensional array of constraints whose attribute values are
being modified.newvals - The desired new values for the attribute for each input constraint.GRBExceptionpublic void set(GRB.CharAttr attr, GRBQConstr[] qconstrs, char[] newvals) throws GRBException
attr - The attribute being modified.qconstrs - The quadratic constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, double[] newvals) throws GRBException
attr - The attribute being modified.qconstrs - The quadratic constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBQConstr[] qconstrs, String[] newvals) throws GRBException
attr - The attribute being modified.qconstrs - The quadratic constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBException@Deprecated public void set(GRB.CharAttr attr, GRBQConstr[] qconstrs, char[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.DoubleAttr attr, GRBQConstr[] qconstrs, double[] newvals, int start, int len) throws GRBException
GRBException@Deprecated public void set(GRB.StringAttr attr, GRBQConstr[] qconstrs, String[] newvals, int start, int len) throws GRBException
GRBExceptionpublic void set(GRB.CharAttr attr, GRBQConstr[][] qconstrs, char[][] newvals) throws GRBException
attr - The attribute being modified.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBQConstr[][] qconstrs, double[][] newvals) throws GRBException
attr - The attribute being modified.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBQConstr[][] qconstrs, String[][] newvals) throws GRBException
attr - The attribute being modified.qconstrs - A two-dimensional array of quadratic constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.CharAttr attr, GRBQConstr[][][] qconstrs, char[][][] newvals) throws GRBException
attr - The attribute being modified.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.DoubleAttr attr, GRBQConstr[][][] qconstrs, double[][][] newvals) throws GRBException
attr - The attribute being modified.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBQConstr[][][] qconstrs, String[][][] newvals) throws GRBException
attr - The attribute being modified.qconstrs - A three-dimensional array of quadratic constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input quadratic
constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBGenConstr[] genconstrs, String[] newvals) throws GRBException
attr - The attribute being modified.genconstrs - The general constraints whose attribute values are being modified.newvals - The desired new values for the attribute for each input general
constraint.GRBException@Deprecated public void set(GRB.StringAttr attr, GRBGenConstr[] genconstrs, String[] newvals, int start, int len) throws GRBException
GRBExceptionpublic void set(GRB.StringAttr attr, GRBGenConstr[][] genconstrs, String[][] newvals) throws GRBException
attr - The attribute being modified.genconstrs - A two-dimensional array of general constraints whose attribute values
are being modified.newvals - The desired new values for the attribute for each input general
constraint.GRBExceptionpublic void set(GRB.StringAttr attr, GRBGenConstr[][][] genconstrs, String[][][] newvals) throws GRBException
attr - The attribute being modified.genconstrs - A three-dimensional array of general constraints whose attribute
values are being modified.newvals - The desired new values for the attribute for each input general
constraint.GRBExceptionpublic void prefetchAttr(GRB.IntAttr attr) throws GRBException
GRBExceptionpublic void prefetchAttr(GRB.CharAttr attr) throws GRBException
GRBExceptionpublic void prefetchAttr(GRB.DoubleAttr attr) throws GRBException
GRBExceptionpublic void prefetchAttr(GRB.StringAttr attr) throws GRBException
GRBExceptionpublic void setCallback(GRBCallback cb) throws GRBException
callback() method on
this object will be called periodically from the Gurobi solver. You
will have the opportunity to obtain more detailed information about
the state of the optimization from this callback. See the
documentation for GRBCallback
for additional information.
Note that a model can only have a single callback method, so this call will replace an existing callback.
cb - New callback object. To disable a previously set callback, call this
method with a null argument.GRBExceptionpublic void setLogCallback(Consumer<String> logCallback) throws GRBException
logCallback - The logging callback function.GRBExceptionpublic int FSolve(int blen,
int[] bind,
double[] bval,
int[] xind,
double[] xval)
throws GRBException
GRBExceptionpublic int BinvColj(int col,
int[] xind,
double[] xval)
throws GRBException
GRBExceptionpublic int Binvj(int j,
int[] xind,
double[] xval)
throws GRBException
GRBExceptionpublic int BSolve(int blen,
int[] bind,
double[] bval,
int[] xind,
double[] xval)
throws GRBException
GRBExceptionpublic int Binvi(int i,
int[] xind,
double[] xval)
throws GRBException
GRBExceptionpublic int BinvRowi(int i,
int[] xind,
double[] xval)
throws GRBException
GRBExceptionpublic void BasisHead(int[] bhead)
throws GRBException
GRBExceptionCopyright © 2025 Gurobi Optimization, LLC. All rights reserved.