Model Queries#
While most model related queries are handled through the attribute interface, a few fall outside of that interface. These are described here.

int GRBgetcoeff(GRBmodel *model, int constrind, int varind, double *valP)#
Retrieve a single constraint matrix coefficient.
 Return value:
A nonzero return value indicates that a problem occurred while retrieving the coefficient. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the coefficient should be retrieved.
constrind – The constraint index for the desired coefficient.
varind – The variable index for the desired coefficient.
valP – The location in which the requested matrix coefficient should be placed.
 Example:
double A12; error = GRBgetcoeff(model, 1, 2, &A12);

int GRBgetconstrbyname(GRBmodel *model, const char *name, int *constrnumP)#
Retrieves a linear constraint from its name. If multiple linear constraints have the same name, this routine chooses one arbitrarily.
 Return value:
A nonzero return value indicates that a problem occurred while retrieving the constraint. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the linear constraint should be retrieved.
name – The name of the desired linear constraint.
constrnumP – Constraint number for a linear constraint with the indicated name. Returns 1 if no matching name is found.

int GRBgetconstrs(GRBmodel *model, int *numnzP, int *cbeg, int *cind, double *cval, int start, int len)#
Retrieve the nonzeros for a set of linear constraints from the constraint matrix. Typical usage is to call this routine twice. In the first call, you specify the requested set of constraints, with
NULL
values forcbeg
,cind
, andcval
. The routine returns the number of nonzero values for the specified constraint range innumnzP
. That allows you to make certain thatcind
andcval
are of sufficient size to hold the result of the second call.If your constraint matrix may contain more than 2 billion nonzero values, you should consider using the
GRBXgetconstrs
variant of this routine. Return value:
A nonzero return value indicates that a problem occurred while retrieving the constraint coefficients. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the linear constraints should be retrieved.
numnzP – The number of nonzero values retrieved.
cbeg – Constraint matrix nonzero values are returned in Compressed Sparse Row (CSR) format. Each constraint in the constraint matrix is represented as a list of indexvalue pairs, where each index entry provides the variable index for a nonzero coefficient, and each value entry provides the corresponding nonzero value. Each constraint has an associated
cbeg
value, indicating the start position of the nonzeros for that constraint in thecind
andcval
arrays. The nonzeros for constrainti
immediately follow those for constrainti1
incind
andcval
. Thus,cbeg[i]
indicates both the index of the first nonzero in constrainti
and the end of the nonzeros for constrainti1
. For example, consider the case wherecbeg[2] = 10
andcbeg[3] = 12
. This would indicate that constraint 2 has two nonzero values associated with it. Their variable indices can be found incind[10]
andcind[11]
, and the numerical values for those nonzeros can be found incval[10]
andcval[11]
.cind – Variable indices associated with nonzero values. See the description of the
cbeg
argument for more information.cval – Numerical values associated with constraint matrix nonzeros. See the description of the
cbeg
argument for more information.start – The index of the first linear constraint to retrieve.
len – The number of linear constraints to retrieve.

GRBenv *GRBgetenv(GRBmodel *model)#
Retrieve the environment associated with a model.
Note that this environment is a model environment, not the original environment on which the model was created. See Algorithmic parameters for more information.
 Return value:
The environment associated with the model. A
NULL
return value indicates that there was a problem retrieving the environment. Arguments:
model – The model from which the environment should be retrieved.
 Example:
GRBenv *env = GRBgetenv(model);

int GRBgetgenconstrMax(GRBmodel *model, int id, int *resvarP, int *nvarsP, int *vars, double *constantP)#
Retrieve the data associated with a general constraint of type MAX. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thevars
argument. The routine returns the total number of operand variables in the specified general constraint innvarsP
. That allows you to make certain that thevars
array is of sufficient size to hold the result of the second call.See also
GRBaddgenconstrMax
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the resultant variable of the constraint.
nvarsP – The number of operand variables of the constraint.
vars – An array to store the variable indices associated with the variable operands of the constraint.
constantP – The additional constant operand of the constraint.
 Example:
int type; int resvar; int nvars; int *vars; double constant; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_MAX) { error = GRBgetgenconstrMax(model, 3, &resvar, &nvars, NULL, &constant); /* ...allocate vars to hold 'nvars' values... */ error = GRBgetgenconstrMax(model, 3, NULL, NULL, vars, NULL); }

int GRBgetgenconstrMin(GRBmodel *model, int id, int *resvarP, int *nvarsP, int *vars, double *constantP)#
Retrieve the data associated with a general constraint of type MIN. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thevars
argument. The routine returns the total number of operand variables in the specified general constraint innvarsP
. That allows you to make certain that thevars
array is of sufficient size to hold the result of the second call.See also
GRBaddgenconstrMin
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the resultant variable of the constraint.
nvarsP – The number of operand variables of the constraint.
vars – An array to store the variable indices associated with the variable operands of the constraint.
constantP – The additional constant operand of the constraint.
 Example:
int type; int resvar; int nvars; int *vars; double constant; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_MIN) { error = GRBgetgenconstrMin(model, 3, &resvar, &nvars, NULL, &constant); /* ...allocate vars to hold 'nvars' values... */ error = GRBgetgenconstrMin(model, 3, NULL, NULL, vars, NULL); }

int GRBgetgenconstrAbs(GRBmodel *model, int id, int *resvarP, int *argvarP)#
Retrieve the data associated with a general constraint of type ABS. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrAbs
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the resultant variable of the constraint.
argvarP – The variable index associated with the argument variable of the constraint.
 Example:
int type; int resvar; int argvar; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_ABS) { error = GRBgetgenconstrAbs(model, 3, &resvar, &argvar); }

int GRBgetgenconstrAnd(GRBmodel *model, int id, int *resvarP, int *nvarsP, int *vars)#
Retrieve the data associated with a general constraint of type AND. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thevars
argument. The routine returns the total number of operand variables in the specified general constraint innvarsP
. That allows you to make certain that thevars
array is of sufficient size to hold the result of the second call.See also
GRBaddgenconstrAnd
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the binary resultant variable of the constraint.
nvarsP – The number of binary operand variables of the constraint.
vars – An array to store the variable indices associated with the binary variable operands of the constraint.
 Example:
int type; int resvar; int nvars; int *vars; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_AND) { error = GRBgetgenconstrAnd(model, 3, &resvar, &nvars, NULL); /* ...allocate vars to hold 'nvars' values... */ error = GRBgetgenconstrAnd(model, 3, NULL, NULL, vars); }

int GRBgetgenconstrOr(GRBmodel *model, int id, int *resvarP, int *nvarsP, int *vars)#
Retrieve the data associated with a general constraint of type OR. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thevars
argument. The routine returns the total number of operand variables in the specified general constraint innvarsP
. That allows you to make certain that thevars
array is of sufficient size to hold the result of the second call.See also
GRBaddgenconstrOr
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the binary resultant variable of the constraint.
nvarsP – The number of binary operand variables of the constraint.
vars – An array to store the variable indices associated with the binary variable operands of the constraint.
 Example:
int type; int resvar; int nvars; int *vars; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_OR) { error = GRBgetgenconstrOr(model, 3, &resvar, &nvars, NULL); /* ...allocate vars to hold 'nvars' values... */ error = GRBgetgenconstrOr(model, 3, NULL, NULL, vars); }

int GRBgetgenconstrNorm(GRBmodel *model, int id, int *resvarP, int *nvarsP, int *vars, double *whichP)#
Retrieve the data associated with a general constraint of type NORM. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thevars
argument. The routine returns the total number of operand variables in the specified general constraint innvarsP
. That allows you to make certain that thevars
array is of sufficient size to hold the result of the second call.See also
GRBaddgenconstrNorm
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the resultant variable of the constraint.
nvarsP – The number of operand variables of the constraint.
vars – An array to store the variable indices associated with the variable operands of the constraint.
whichP – Which norm is used. Options are 0, 1, 2, and GRB_INFINITY.
 Example:
int type; int resvar; int nvars; int *vars; double which; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_NORM) { error = GRBgetgenconstrNorm(model, 3, &resvar, &nvars, NULL, &which); /* ...allocate vars to hold 'nvars' values... */ error = GRBgetgenconstrNorm(model, 3, NULL, NULL, vars); }

int GRBgetgenconstrNL(GRBmodel *model, int id, int *resvarP, int *nnodesP, int *opcode, double *data, int *parent)#
Retrieve the data associated with a general constraint of type NL. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for theopcode
,data
andparent
arguments. The routine returns the total number of nodes that form the expression tree for the specified general constraint innnodesP
. That allows you to make certain that theopcode
,data
andparent
arrays are of sufficient size to hold the result of the second call.See also Nonlinear Constraints and
GRBaddgenconstrNL
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
resvarP – The variable index associated with the resultant variable of the constraint.
nnodesP – The number of nodes in the expression tree for this constraint.
opcode – An array to store the nodes’ operation codes.
data – An array to store the nodes’ auxiliary data items.
parent – An array to store the nodes’ parent indices.
 Example:
int type; int resvar; int nnodes; int *opcode, *parent; double *data; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_NL) { error = GRBgetgenconstrNL(model, 3, &resvar, &nnodes, NULL, NULL, NULL); /* ...allocate opcode, data, parent to hold 'nnodes' values... */ error = GRBgetgenconstrNL(model, 3, NULL, NULL, opcode, data, parent); }

int GRBgetgenconstrIndicator(GRBmodel *model, int id, int *binvarP, int *binvalP, int *nvarsP, int *ind, double *val, char *senseP, double *rhsP)#
Retrieve the data associated with a general constraint of type INDICATOR. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with
NULL
values for theind
andval
arguments. The routine returns the total number of nonzero coefficients in the linear constraint associated with the specified indicator constraint innvarsP
. That allows you to make certain that theind
andval
arrays are of sufficient size to hold the result of the second call.See also
GRBaddgenconstrIndicator
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
binvarP – The variable index associated with the binary indicator variable.
binvalP – The value that the indicator variable has to take in order to trigger the linear constraint.
nvarsP – The number of nonzero coefficients in the linear constraint triggered by the indicator.
ind – An array to store the variable indices for nonzero values in the linear constraint.
val – An array to store the numerical values for nonzero values in the linear constraint.
senseP – Sense for the linear constraint. Options are
GRB_LESS_EQUAL
,GRB_EQUAL
, orGRB_GREATER_EQUAL
.rhsP – Righthand side value for the linear constraint.
 Example:
int type; int binvar; int binval: int nvars; int *ind; double *val; char sense; double rhs; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_INDICATOR) { error = GRBgetgenconstrIndicator(model, 3, &binvar, &binval, &nvars, NULL, NULL, &sense, &rhs); /* ...allocate ind and val to hold 'nvars' values... */ error = GRBgetgenconstrIndicator(model, 3, NULL, NULL, NULL, ind, val, NULL, NULL); }

int GRBgetgenconstrPWL(GRBmodel *model, int id, int *xvarP, int *yvarP, int *nptsP, double *xpts, double *ypts)#
Retrieve the data associated with a general constraint of type PWL. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thexpts
andypts
arguments. The routine returns the length for thexpts
andypts
arrays innptsP
. That allows you to make certain that thexpts
andypts
arrays are of sufficient size to hold the result of the second call.See also
GRBaddgenconstrPWL
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
nptsP – The number of points that define the piecewiselinear function.
xpts – The \(x\) values for the points that define the piecewiselinear function.
ypts – The \(y\) values for the points that define the piecewiselinear function.
 Example:
int type; int xvar; int yvar; int npts; double *xpts; double *ypts; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_PWL) { error = GRBgetgenconstrPWL(model, 3, &xvar, &yvar, &npts, NULL, NULL); /* ...allocate xpts and ypts arrays with length npts */ error = GRBgetgenconstrPWL(model, 3, NULL, NULL, NULL, xpts, ypts); }

int GRBgetgenconstrPoly(GRBmodel *model, int id, int *xvarP, int *yvarP, int *plenP, double *p)#
Retrieve the data associated with a general constraint of type POLY. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
Typical usage is to call this routine twice. In the first call, you specify the requested general constraint, with a
NULL
value for thep
argument. The routine returns the length of thep
array inplenP
. That allows you to make certain that thep
array is of sufficient size to hold the result of the second call.See also
GRBaddgenconstrPoly
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
plenP – Pointer to 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.
 Example:
int type; int xvar; int yvar; int plen; double *p; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_POLY) { error = GRBgetgenconstrPoly(model, 3, &xvar, &yvar, &plen, NULL); /* ...allocate p array with length plen */ error = GRBgetgenconstrPoly(model, 3, NULL, NULL, NULL, p); }

int GRBgetgenconstrExp(GRBmodel *model, int id, int *xvarP, int *yvarP)#
Retrieve the data associated with a general constraint of type EXP. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrExp
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
 Example:
int type; int xvar; int yvar; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_EXP) { error = GRBgetgenconstrExp(model, 3, &xvar, &yvar); }

int GRBgetgenconstrExpA(GRBmodel *model, int id, int *xvarP, int *yvarP, double *aP)#
Retrieve the data associated with a general constraint of type EXPA. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrExpA
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
aP – The base of the function.
 Example:
int type; int xvar; int yvar; double a; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_EXPA) { error = GRBgetgenconstrExpA(model, 3, &xvar, &yvar, &a); }

int GRBgetgenconstrLog(GRBmodel *model, int id, int *xvarP, int *yvarP)#
Retrieve the data associated with a general constraint of type LOG. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrLog
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
 Example:
int type; int xvar; int yvar; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_LOG) { error = GRBgetgenconstrLog(model, 3, &xvar, &yvar); }

int GRBgetgenconstrLogA(GRBmodel *model, int id, int *xvarP, int *yvarP, double *aP)#
Retrieve the data associated with a general constraint of type LOGA. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrLogA
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
aP – The base of the function.
 Example:
int type; int xvar; int yvar; double a; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_LOGA) { error = GRBgetgenconstrLogA(model, 3, &xvar, &yvar, &a); }

int GRBgetgenconstrLogistic(GRBmodel *model, int id, int *xvarP, int *yvarP)#
Retrieve the data associated with a general constraint of type LOGISTIC. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrLogistic
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
 Example:
int type; int xvar; int yvar; double a; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_LOGISTIC) { error = GRBgetgenconstrLogistic(model, 3, &xvar, &yvar); }

int GRBgetgenconstrPow(GRBmodel *model, int id, int *xvarP, int *yvarP, double *aP)#
Retrieve the data associated with a general constraint of type POW. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrPow
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
aP – The exponent of the function.
 Example:
int type; int xvar; int yvar; double a; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_POW) { error = GRBgetgenconstrPow(model, 3, &xvar, &yvar, &a); }

int GRBgetgenconstrSin(GRBmodel *model, int id, int *xvarP, int *yvarP)#
Retrieve the data associated with a general constraint of type SIN. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrSin
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
 Example:
int type; int xvar; int yvar; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_SIN) { error = GRBgetgenconstrSin(model, 3, &xvar, &yvar); }

int GRBgetgenconstrCos(GRBmodel *model, int id, int *xvarP, int *yvarP)#
Retrieve the data associated with a general constraint of type COS. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrCos
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
 Example:
int type; int xvar; int yvar; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_COS) { error = GRBgetgenconstrCos(model, 3, &xvar, &yvar); }

int GRBgetgenconstrTan(GRBmodel *model, int id, int *xvarP, int *yvarP)#
Retrieve the data associated with a general constraint of type TAN. Calling this method for a general constraint of a different type leads to an error return code. You can query the GenConstrType attribute to determine the type of the general constraint.
See also
GRBaddgenconstrTan
for a description of the semantics of this general constraint type. Return value:
A nonzero return value indicates that a problem occurred while retrieving the general constraint data. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model that contains the desired general constraint.
id – The index of the general constraint to retrieve.
Note that any of the following arguments can be
NULL
. Arguments:
xvarP – The index of variable \(x\).
yvarP – The index of variable \(y\).
 Example:
int type; int xvar; int yvar; error = GRBgetintattrelement(model, GRB_INT_ATTR_GENCONSTRTYPE, 3, &type); if (type == GRB_GENCONSTR_TAN) { error = GRBgetgenconstrTan(model, 3, &xvar, &yvar); }

int GRBgetjsonsolution(GRBmodel model, char **buffP)#
After a call to
optimize
, this method returns the resulting solution and related model attributes as a JSON string. Please refer to the JSON solution format section for details. Return value:
A nonzero return value indicates that there was a problem generating the JSON solution string. Refer to the Error Codes table for a list of possible return values.
 Arguments:
model – Model from which to query its current JSON solution string.
buffP – The location in which the pointer to the newly created JSON string should be placed.
Important
On Windows, the string returned in
buffP
is allocated in a different heap from the calling program. You must callGRBfree
to free it.

int GRBgetpwlobj(GRBmodel *model, int var, int *npointsP, double *x, double *y)#
Retrieve the piecewiselinear objective function for a variable. The \(x\) and \(y\) arguments must be large enough to hold the result. If either are NULL, then
npointsP
will contain the number of points in the function on return.Refer to this discussion for additional information on what the values in \(x\) and \(y\) mean.
 Return value:
A nonzero return value indicates that a problem occurred while retrieving the piecewiselinear objective function. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the piecewiselinear objective function is being retrieved.
var – The variable whose objective function is being retrieved.
npointsP – The number of points that define the piecewiselinear function.
x – The \(x\) values for the points that define the piecewiselinear function. These will always be in nondecreasing order.
y – The \(y\) values for the points that define the piecewiselinear function.
 Example:
double *x; double *y; error = GRBgetpwlobj(model, var, &npoints, NULL, NULL); /* ...allocate x and y to hold 'npoints' values... */ error = GRBgetpwlobj(model, var, &npoints, x, y);

int GRBgetq(GRBmodel *model, int *numqnzP, int *qrow, int *qcol, double *qval)#
Retrieve all quadratic objective terms. The
qrow
,qcol
, andqval
arguments must be large enough to hold the result. You can query the NumQNZs attribute to determine how many terms will be returned. Return value:
A nonzero return value indicates that a problem occurred while retrieving the quadratic objective terms. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the quadratic objective terms should be retrieved.
numqnzP – The number of quadratic objective terms retrieved.
qrow – Row indices associated with quadratic terms. A quadratic term is represented using three values: a pair of indices (stored in
qrow
andqcol
), and a coefficient (stored inqval
). The three argument arrays provide the corresponding values for each quadratic term. To give an example, to represent \(2 x_0^2 + x_0 x_1 + x_1^2\), you would have*numqnzP=3
,qrow[] = {0, 0, 1}
,qcol[] = {0, 1, 1}
, andqval[] = {2.0, 1.0, 1.0}
.qcol – Column indices associated with quadratic terms. See the description of the
qrow
argument for more information.qval – Numerical values associated with quadratic terms. See the description of the
qrow
argument for more information.
 Example:
int qnz; int *qrow, *qcol; double *qval; error = GRBgetdblattr(model, GRB_DBL_ATTR_NUMQNZS, &qnz); /* ...allocate qrow, qcol, qval to hold 'qnz' values... */ error = GRBgetq(model, &qnz, qrow, qcol, qval);

int GRBgetqconstr(GRBmodel *model, int qconstr, int *numlnzP, int *lind, double *lval, int *numqnzP, int *qrow, int *qcol, double *qval)#
Retrieve the linear and quadratic terms associated with a single quadratic constraint. Typical usage is to call this routine twice. In the first call, you specify the requested quadratic constraint, with
NULL
values for the array arguments. The routine returns the total number of linear and quadratic terms in the specified quadratic constraint innumlnzP
andnumqnzP
, respectively. That allows you to make certain thatlind
,lval
,qrow
,qcol
, andqval
are of sufficient size to hold the result of the second call. Return value:
A nonzero return value indicates that a problem occurred while retrieving the quadratic constraint. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the quadratic constraint should be retrieved.
qconstr – The index of the requested quadratic constraint.
numlnzP – The number of linear terms retrieved for the requested quadratic constraint.
lind – Variable indices associated with linear terms.
lval – Numerical coefficients associated with linear terms.
numqnzP – The number of quadratic terms retrieved for the requested quadratic constraint.
qrow – Row indices associated with quadratic terms. A quadratic term is represented using three values: a pair of indices (stored in
qrow
andqcol
), and a coefficient (stored inqval
). The associated arguments arrays provide the corresponding values for each quadratic term. To give an example, if the requested quadratic constraint has quadratic terms \(2 x_0^2 + x_0 x_1 + x_1^2\), this routine would return*numqnzP=3
,qrow[] = {0, 0, 1}
,qcol[] = {0, 1, 1}
, andqval[] = {2.0, 1.0, 1.0}
.qcol – Column indices associated with quadratic terms. See the description of the
qrow
argument for more information.qval – Numerical values associated with quadratic terms. See the description of the
qrow
argument for more information.

int GRBgetqconstrbyname(GRBmodel *model, const char *name, int *constrnumP)#
Retrieves a quadratic constraint from its name. If multiple quadratic constraints have the same name, this routine chooses one arbitrarily.
 Return value:
A nonzero return value indicates that a problem occurred while retrieving the quadratic constraint. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the quadratic constraint should be retrieved.
name – The name of the desired quadratic constraint.
constrnumP – Constraint number for a quadratic constraint with the indicated name. Returns 1 if no matching name is found.

int GRBgetsos(GRBmodel *model, int *nummembersP, int *sostype, int *beg, int *ind, double *weight, int start, int len)#
Retrieve the members and weights of a set of SOS constraints. Typical usage is to call this routine twice. In the first call, you specify the requested SOS constraints, with
NULL
values forind
andweight
. The routine returns the total number of members for the specified SOS constraints innummembersP
. That allows you to make certain thatind
andweight
are of sufficient size to hold the result of the second call. Return value:
A nonzero return value indicates that a problem occurred while retrieving the SOS members. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the SOS constraints should be retrieved.
nummembersP – The total number of SOS members retrieved.
sostype – The types of the SOS constraints. Possible values are
GRB_SOS_TYPE1
orGRB_SOS_TYPE2
.beg – SOS constraints are returned in Compressed Sparse Row (CSR) format. Each SOS constraint in the model is represented as a list of indexvalue pairs, where each index entry provides the variable index for an SOS member, and each value entry provides the corresponding SOS constraint weight. Each SOS constraint has an associated
beg
value, indicating the start position of the members of that constraint in theind
andweight
arrays. The members for SOS constrainti
immediately follow those for constrainti1
inind
andweight
. Thus,beg[i]
indicates both the index of the first member of SOS constrainti
and the end of the member list for SOS constrainti1
. For example, consider the case wherebeg[2] = 10
andbeg[3] = 12
. This would indicate that SOS constraint 2 has two members. Their variable indices can be found inind[10]
andind[11]
, and their SOS weights can be found inweight[10]
andweight[11]
.ind – Variable indices associated with SOS members. See the description of the
beg
argument for more information.weight – Weights associated with SOS members. See the description of the
beg
argument for more information.start – The index of the first SOS constraint to retrieve.
len – The number of SOS constraints to retrieve.

int GRBgetvarbyname(GRBmodel *model, const char *name, int *varnumP)#
Retrieves a variable from its name. If multiple variables have the same name, this routine chooses one arbitrarily.
 Return value:
A nonzero return value indicates that a problem occurred while retrieving the variable. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the variable should be retrieved.
name – The name of the desired variable.
varnumP – Variable number for a variable with the indicated name. Returns 1 if no matching name is found.

int GRBgetvars(GRBmodel *model, int *numnzP, int *vbeg, int *vind, double *vval, int start, int len)#
Retrieve the nonzeros for a set of variables from the constraint matrix. Typical usage is to call this routine twice. In the first call, you specify the requested set of variables, with
NULL
values forvbeg
,vind
, andvval
. The routine returns the number of nonzero values for the specified variables innumnzP
. That allows you to make certain thatvind
andvval
are of sufficient size to hold the result of the second call.If your constraint matrix may contain more than 2 billion nonzero values, you should consider using the
GRBXgetvars
variant of this routine. Return value:
A nonzero return value indicates that a problem occurred while retrieving the variable coefficients. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the variables should be retrieved.
numnzP – The number of nonzero values retrieved.
vbeg – Constraint matrix nonzero values are returned in Compressed Sparse Column (CSC) format by this routine. Each column in the constraint matrix is represented as a list of indexvalue pairs, where each index entry provides the constraint index for a nonzero coefficient, and each value entry provides the corresponding nonzero value. Each variable has an associated
vbeg
value, indicating the start position of the nonzeros for that constraint in thevind
andvval
arrays. The nonzeros for variablei
immediately follow those for variablei1
invind
andvval
. Thus,vbeg[i]
indicates both the index of the first nonzero in variablei
and the end of the nonzeros for variablei1
. For example, consider the case wherevbeg[2] = 10
andvbeg[3] = 12
. This would indicate that variable 2 has two nonzero values associated with it. Their constraint indices can be found invind[10]
andvind[11]
, and the numerical values for those nonzeros can be found invval[10]
andvval[11]
.vind – Constraint indices associated with nonzero values. See the description of the
vbeg
argument for more information.vval – Numerical values associated with constraint matrix nonzeros. See the description of the
vbeg
argument for more information.start – The index of the first variable to retrieve.
len – The number of variables to retrieve.

int GRBsinglescenariomodel(GRBmodel *model, GRBmodel **singlescenarioP)#
Capture a single scenario from a multiscenario model. Use the ScenarioNumber parameter to indicate which scenario to capture.
 Return value:
A nonzero return value indicates that a problem occurred while extracting the singlescenario model. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the scenario should be extracted.
singlescenarioP – The location in which the pointer to the requested singlescenario model should be placed.

int GRBXgetconstrs(GRBmodel *model, size_t *numnzP, size_t *cbeg, int *cind, double *cval, int start, int len)#
The
size_t
version ofGRBgetconstrs
. The two arguments that count nonzero values are of typesize_t
in this version to support models with more than 2 billion nonzero values.Retrieve the nonzeros for a set of linear constraints from the constraint matrix. Typical usage is to call this routine twice. In the first call, you specify the requested set of constraints, with
NULL
values forcbeg
,cind
, andcval
. The routine returns the number of nonzero values for the specified constraint range innumnzP
. That allows you to make certain thatcind
andcval
are of sufficient size to hold the result of the second call. Return value:
A nonzero return value indicates that a problem occurred while retrieving the constraint coefficients. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the constraints should be retrieved.
numnzP – The number of nonzero values retrieved.
cbeg – Constraint matrix nonzero values are returned in Compressed Sparse Row (CSR) format. Each constraint in the constraint matrix is represented as a list of indexvalue pairs, where each index entry provides the variable index for a nonzero coefficient, and each value entry provides the corresponding nonzero value. Each constraint has an associated
cbeg
value, indicating the start position of the nonzeros for that constraint in thecind
andcval
arrays. The nonzeros for constrainti
immediately follow those for constrainti1
incind
andcval
. Thus,cbeg[i]
indicates both the index of the first nonzero in constrainti
and the end of the nonzeros for constrainti1
. For example, consider the case wherecbeg[2] = 10
andcbeg[3] = 12
. This would indicate that constraint 2 has two nonzero values associated with it. Their variable indices can be found incind[10]
andcind[11]
, and the numerical values for those nonzeros can be found incval[10]
andcval[11]
.cind – Variable indices associated with nonzero values. See the description of the
cbeg
argument for more information.cval – Numerical values associated with constraint matrix nonzeros. See the description of the
cbeg
argument for more information.start – The index of the first constraint to retrieve.
len – The number of constraints to retrieve.

int GRBXgetvars(GRBmodel *model, size_t *numnzP, size_t *vbeg, int *vind, double *vval, int start, int len)#
The
size_t
version ofGRBgetvars
. The two arguments that count nonzero values are of typesize_t
in this version to support models with more than 2 billion nonzero values.Retrieve the nonzeros for a set of variables from the constraint matrix. Typical usage is to call this routine twice. In the first call, you specify the requested set of variables, with
NULL
values forvbeg
,vind
, andvval
. The routine returns the number of nonzero values for the specified variables innumnzP
. That allows you to make certain thatvind
andvval
are of sufficient size to hold the result of the second call. Return value:
A nonzero return value indicates that a problem occurred while retrieving the variable coefficients. Refer to the Error Codes table for a list of possible return values. Details on the error can be obtained by calling
GRBgeterrormsg
. Arguments:
model – The model from which the variables should be retrieved.
numnzP – The number of nonzero values retrieved.
vbeg – Constraint matrix nonzero values are returned in Compressed Sparse Column (CSC) format by this routine. Each column in the constraint matrix is represented as a list of indexvalue pairs, where each index entry provides the constraint index for a nonzero coefficient, and each value entry provides the corresponding nonzero value. Each variable has an associated
vbeg
value, indicating the start position of the nonzeros for that constraint in thevind
andvval
arrays. The nonzeros for variablei
immediately follow those for variablei1
invind
andvval
. Thus,vbeg[i]
indicates both the index of the first nonzero in variablei
and the end of the nonzeros for variablei1
. For example, consider the case wherevbeg[2] = 10
andvbeg[3] = 12
. This would indicate that variable 2 has two nonzero values associated with it. Their constraint indices can be found invind[10]
andvind[11]
, and the numerical values for those nonzeros can be found invval[10]
andvval[11]
.vind – Constraint indices associated with nonzero values. See the description of the
vbeg
argument for more information.vval – Numerical values associated with constraint matrix nonzeros. See the description of the
vbeg
argument for more information.start – The index of the first variable to retrieve.
len – The number of variables to retrieve.