gurobipy 10.0.1__cp311-cp311-macosx_10_9_universal2.whl → 13.0.0__cp311-cp311-macosx_10_9_universal2.whl

gurobipy/_errorconst.py

@@ -0,0 +1,80 @@
+# Wrapper for 'GRB.Error' object
+
+class ErrorConstClass(object):
+  '''
+  Gurobi error codes (e.g., exception.errno == GRB.ERROR_OUT_OF_MEMORY):
+
+    OUT_OF_MEMORY: Exhausted available memory
+    NULL_ARGUMENT: NULL argument value
+    INVALID_ARGUMENT: Invalid argument value
+    UNKNOWN_ATTRIBUTE: Unknown attribute name
+    DATA_NOT_AVAILABLE: Requested data not available
+    INDEX_OUT_OF_RANGE: Constr/var index out of range
+    UNKNOWN_PARAMETER: Unknown parameter name
+    VALUE_OUT_OF_RANGE: Parameter value outside of valid range
+    NO_LICENSE: No Gurobi license found
+    SIZE_LIMIT_EXCEEDED: Exceeded licensed model size limit
+    CALLBACK: Error in callback
+    FILE_READ: Error reading file
+    FILE_WRITE: Error writing file
+    NUMERIC: Numeric error encountered
+    IIS_NOT_INFEASIBLE: Can't compute an IIS on a feasible model
+    NOT_FOR_MIP: Method not valid for MIP models
+    OPTIMIZATION_IN_PROGRESS: Must stop optimization to query results
+    DUPLICATES: Duplicate entries in list
+    NODEFILE: Problem reading or writing node file
+    Q_NOT_PSD: Q matrix isn't Positive Semi-Definite
+    QCP_EQUALITY_CONSTRAINT: Quadratic constraints must be inequalities
+    NETWORK: Network error
+    JOB_REJECTED: Job rejected by Compute Server
+    NOT_SUPPORTED: Requested operation is not supported
+    EXCEED_2B_NONZEROS: Result too large for query routine
+    INVALID_PIECEWISE_OBJ: Problem with specified piecewise-linear objective
+    JOB_REJECTED: Job rejected by Compute Server
+    NOT_SUPPORTED: Operation is not supported
+    NOT_IN_MODEL: Variable/constraint not in model
+    FAILED_TO_CREATE_MODEL: Failed to create the requested model
+    CLOUD: Instant Cloud error
+    MODEL_MODIFICATION: An error occurred during model modification or update
+    CSWORKER: An error occurred with the client-server application
+    TUNE_MODEL_TYPES: Tried multi-model tuning on models of different types
+    INTERNAL: Internal Gurobi error
+  '''
+
+  def __setattr__(self, name, value):
+    raise AttributeError("Gurobi error code constants are not modifiable")
+
+  OUT_OF_MEMORY            = 10001
+  NULL_ARGUMENT            = 10002
+  INVALID_ARGUMENT         = 10003
+  UNKNOWN_ATTRIBUTE        = 10004
+  DATA_NOT_AVAILABLE       = 10005
+  INDEX_OUT_OF_RANGE       = 10006
+  UNKNOWN_PARAMETER        = 10007
+  VALUE_OUT_OF_RANGE       = 10008
+  NO_LICENSE               = 10009
+  SIZE_LIMIT_EXCEEDED      = 10010
+  CALLBACK                 = 10011
+  FILE_READ                = 10012
+  FILE_WRITE               = 10013
+  NUMERIC                  = 10014
+  IIS_NOT_INFEASIBLE       = 10015
+  NOT_FOR_MIP              = 10016
+  OPTIMIZATION_IN_PROGRESS = 10017
+  DUPLICATES               = 10018
+  NODEFILE                 = 10019
+  Q_NOT_PSD                = 10020
+  QCP_EQUALITY_CONSTRAINT  = 10021
+  NETWORK                  = 10022
+  JOB_REJECTED             = 10023
+  NOT_SUPPORTED            = 10024
+  EXCEED_2B_NONZEROS       = 10025
+  INVALID_PIECEWISE_OBJ    = 10026
+  UPDATEMODE_CHANGE        = 10027
+  CLOUD                    = 10028
+  MODEL_MODIFICATION       = 10029
+  CSWORKER                 = 10030
+  TUNE_MODEL_TYPES         = 10031
+  NOT_IN_MODEL             = 20001
+  FAILED_TO_CREATE_MODEL   = 20002
+  INTERNAL                 = 20003

gurobipy/_grb.py

@@ -0,0 +1,298 @@
+# GRB class - constants
+
+from gurobipy._attrconst import AttrConstClass
+from gurobipy._callbackconst import CallbackConstClass
+from gurobipy._errorconst import ErrorConstClass
+from gurobipy._paramconst import ParamConstClass
+from gurobipy._statusconst import StatusConstClass
+
+
+class GRB(object):
+  '''
+  Gurobi constants.  Constants defined in this class are as follows:
+
+    Basis status (e.g., var.vBasis == GRB.BASIC):
+
+      BASIC: Variable is basic
+      NONBASIC_LOWER: Variable is non-basic at lower bound
+      NONBASIC_UPPER: Variable is non-basic at upper bound
+      SUPERBASIC: Variable is superbasic
+
+    Constraint sense (e.g., constr.sense = GRB.LESS_EQUAL):
+
+      LESS_EQUAL, GREATER_EQUAL, EQUAL
+
+    Variable types (e.g., var.vType = GRB.INTEGER):
+
+      CONTINUOUS, BINARY, INTEGER, SEMICONT, SEMIINT
+
+    SOS types:
+
+      SOS_TYPE1, SOS_TYPE2
+
+    General constraint types:
+
+      GENCONSTR_MAX, GENCONSTR_MIN, GENCONSTR_ABS, GENCONSTR_AND, GENCONSTR_OR,
+      GENCONSTR_NORM, GENCONSTR_NL, GENCONSTR_INDICATOR, GENCONSTR_PWL,
+      GENCONSTR_POLY, GENCONSTR_EXP, GENCONSTR_EXPA, GENCONSTR_LOG,
+      GENCONSTR_LOGA, GENCONSTR_POW, GENCONSTR_SIN, GENCONSTR_COS, GENCONSTR_TAN
+
+  The GRB class also includes definitions for attributes (GRB.attr),
+  errors (GRB.error), parameters (GRB.param), status codes (GRB.status),
+  and callbacks (GRB.callback).  You can ask for help on any of these
+  (e.g., "help(GRB.attr)").
+  '''
+
+  attr     = Attr     = AttrConstClass()
+  param    = Param    = ParamConstClass()
+  callback = Callback = CallbackConstClass()
+  error    = Error    = ErrorConstClass()
+  status   = Status   = StatusConstClass()
+
+# Status codes
+
+  LOADED             = 1
+  OPTIMAL            = 2
+  INFEASIBLE         = 3
+  INF_OR_UNBD        = 4
+  UNBOUNDED          = 5
+  CUTOFF             = 6
+  ITERATION_LIMIT    = 7
+  NODE_LIMIT         = 8
+  TIME_LIMIT         = 9
+  SOLUTION_LIMIT     = 10
+  INTERRUPTED        = 11
+  NUMERIC            = 12
+  SUBOPTIMAL         = 13
+  INPROGRESS         = 14
+  USER_OBJ_LIMIT     = 15
+  WORK_LIMIT         = 16
+  MEM_LIMIT          = 17
+  LOCALLY_OPTIMAL    = 18
+  LOCALLY_INFEASIBLE = 19
+
+# Batch status codes
+
+  BATCH_CREATED   = 1
+  BATCH_SUBMITTED = 2
+  BATCH_ABORTED   = 3
+  BATCH_FAILED    = 4
+  BATCH_COMPLETED = 5
+
+# Constraint senses
+
+  LESS_EQUAL    = '<'
+  GREATER_EQUAL = '>'
+  EQUAL         = '='
+
+# Variable types
+
+  CONTINUOUS = 'C'
+  BINARY     = 'B'
+  INTEGER    = 'I'
+  SEMICONT   = 'S'
+  SEMIINT    = 'N'
+
+# Objective sense
+
+  MINIMIZE = 1
+  MAXIMIZE = -1
+
+# SOS types
+
+  SOS_TYPE1 = 1
+  SOS_TYPE2 = 2
+
+# General constraint types
+
+  GENCONSTR_MAX       = 0
+  GENCONSTR_MIN       = 1
+  GENCONSTR_ABS       = 2
+  GENCONSTR_AND       = 3
+  GENCONSTR_OR        = 4
+  GENCONSTR_NORM      = 5
+  GENCONSTR_NL        = 6
+  GENCONSTR_INDICATOR = 7
+  GENCONSTR_PWL       = 8
+  GENCONSTR_POLY      = 9
+  GENCONSTR_EXP       = 10
+  GENCONSTR_EXPA      = 11
+  GENCONSTR_LOG       = 12
+  GENCONSTR_LOGA      = 13
+  GENCONSTR_POW       = 14
+  GENCONSTR_SIN       = 15
+  GENCONSTR_COS       = 16
+  GENCONSTR_TAN       = 17
+  GENCONSTR_LOGISTIC  = 18
+
+# Operation codes
+  OPCODE_CONSTANT     = 0
+  OPCODE_VARIABLE     = 1
+  OPCODE_PLUS         = 2
+  OPCODE_MINUS        = 3
+  OPCODE_MULTIPLY     = 4
+  OPCODE_DIVIDE       = 5
+  OPCODE_UMINUS       = 6
+  OPCODE_SQUARE       = 7
+  OPCODE_SQRT         = 8
+  OPCODE_SIN          = 9
+  OPCODE_COS          = 10
+  OPCODE_TAN          = 11
+  OPCODE_POW          = 12
+  OPCODE_EXP          = 13
+  OPCODE_LOG          = 14
+  OPCODE_LOG2         = 15
+  OPCODE_LOG10        = 16
+  OPCODE_LOGISTIC     = 17
+  OPCODE_TANH         = 18
+  OPCODE_SIGNPOW      = 19
+
+# Basis status
+
+  BASIC          = 0
+  NONBASIC_LOWER = -1
+  NONBASIC_UPPER = -2
+  SUPERBASIC     = -3
+
+# Numeric constants
+
+  INFINITY  = 1e100
+  UNDEFINED = 1e101
+  MAXINT    = 2000000000
+
+# Limits
+
+  MAX_NAMELEN    = 255
+  MAX_STRLEN     = 512
+  MAX_TAGLEN     = 10240
+  MAX_CONCURRENT = 64
+
+# Other constants
+
+  DEFAULT_CS_PORT = 61000
+
+# Version number
+
+  VERSION_MAJOR     = 13
+  VERSION_MINOR     = 0
+  VERSION_TECHNICAL = 0
+
+# Errors
+
+  ERROR_OUT_OF_MEMORY            = 10001
+  ERROR_NULL_ARGUMENT            = 10002
+  ERROR_INVALID_ARGUMENT         = 10003
+  ERROR_UNKNOWN_ATTRIBUTE        = 10004
+  ERROR_DATA_NOT_AVAILABLE       = 10005
+  ERROR_INDEX_OUT_OF_RANGE       = 10006
+  ERROR_UNKNOWN_PARAMETER        = 10007
+  ERROR_VALUE_OUT_OF_RANGE       = 10008
+  ERROR_NO_LICENSE               = 10009
+  ERROR_SIZE_LIMIT_EXCEEDED      = 10010
+  ERROR_CALLBACK                 = 10011
+  ERROR_FILE_READ                = 10012
+  ERROR_FILE_WRITE               = 10013
+  ERROR_NUMERIC                  = 10014
+  ERROR_IIS_NOT_INFEASIBLE       = 10015
+  ERROR_NOT_FOR_MIP              = 10016
+  ERROR_OPTIMIZATION_IN_PROGRESS = 10017
+  ERROR_DUPLICATES               = 10018
+  ERROR_NODEFILE                 = 10019
+  ERROR_Q_NOT_PSD                = 10020
+  ERROR_QCP_EQUALITY_CONSTRAINT  = 10021
+  ERROR_NETWORK                  = 10022
+  ERROR_JOB_REJECTED             = 10023
+  ERROR_NOT_SUPPORTED            = 10024
+  ERROR_EXCEED_2B_NONZEROS       = 10025
+  ERROR_INVALID_PIECEWISE_OBJ    = 10026
+  ERROR_UPDATEMODE_CHANGE        = 10027
+  ERROR_CLOUD                    = 10028
+  ERROR_MODEL_MODIFICATION       = 10029
+  ERROR_CSWORKER                 = 10030
+  ERROR_TUNE_MODEL_TYPES         = 10031
+  ERROR_SECURITY                 = 10032
+  ERROR_NOT_IN_MODEL             = 20001
+  ERROR_FAILED_TO_CREATE_MODEL   = 20002
+  ERROR_INTERNAL                 = 20003
+
+# Cuts parameter values
+
+  CUTS_AUTO           = -1
+  CUTS_OFF            = 0
+  CUTS_CONSERVATIVE   = 1
+  CUTS_AGGRESSIVE     = 2
+  CUTS_VERYAGGRESSIVE = 3
+
+# Presolve parameter values
+
+  PRESOLVE_AUTO         = -1
+  PRESOLVE_OFF          = 0
+  PRESOLVE_CONSERVATIVE = 1
+  PRESOLVE_AGGRESSIVE   = 2
+
+# Method parameter values
+
+  METHOD_NONE                             = -1
+  METHOD_AUTO                             = -1
+  METHOD_PRIMAL                           = 0
+  METHOD_DUAL                             = 1
+  METHOD_BARRIER                          = 2
+  METHOD_CONCURRENT                       = 3
+  METHOD_DETERMINISTIC_CONCURRENT         = 4
+  METHOD_DETERMINISTIC_CONCURRENT_SIMPLEX = 5
+  METHOD_PDHG                             = 6
+
+# BarHomogeneous parameter values
+
+  BARHOMOGENEOUS_AUTO = -1
+  BARHOMOGENEOUS_OFF  = 0
+  BARHOMOGENEOUS_ON   = 1
+
+# BarOrder parameter values
+
+  BARORDER_AUTOMATIC        = -1
+  BARORDER_AMD              = 0
+  BARORDER_NESTEDDISSECTION = 1
+
+# MIPFocus parameter values
+
+  MIPFOCUS_BALANCED    = 0
+  MIPFOCUS_FEASIBILITY = 1
+  MIPFOCUS_OPTIMALITY  = 2
+  MIPFOCUS_BESTBOUND   = 3
+
+# SimplexPricing parameter values
+
+  SIMPLEXPRICING_AUTO           = -1
+  SIMPLEXPRICING_PARTIAL        = 0
+  SIMPLEXPRICING_STEEPEST_EDGE  = 1
+  SIMPLEXPRICING_DEVEX          = 2
+  SIMPLEXPRICING_STEEPEST_QUICK = 3
+
+# VarBranch parameter values
+
+  VARBRANCH_AUTO           = -1
+  VARBRANCH_PSEUDO_REDUCED = 0
+  VARBRANCH_PSEUDO_SHADOW  = 1
+  VARBRANCH_MAX_INFEAS     = 2
+  VARBRANCH_STRONG         = 3
+
+# Partition parameter values
+
+  PARTITION_EARLY     = 16
+  PARTITION_ROOTSTART = 8
+  PARTITION_ROOTEND   = 4
+  PARTITION_NODES     = 2
+  PARTITION_CLEANUP   = 1
+
+# Callback phase values
+
+  PHASE_MIP_NOREL   = 0
+  PHASE_MIP_SEARCH  = 1
+  PHASE_MIP_IMPROVE = 2
+
+# FeasRelax method parameter values
+
+  FEASRELAX_LINEAR      = 0
+  FEASRELAX_QUADRATIC   = 1
+  FEASRELAX_CARDINALITY = 2

gurobipy/_load_model.py

@@ -0,0 +1,248 @@
+from gurobipy._grb import GRB
+from gurobipy._lowlevel import _load_model_memoryview, _add_qp_terms_memoryview
+from gurobipy._util import _isscalar
+
+
+def _double_array_argument(arg, size):
+    """If arg is a single value, build a repeating array. Otherwise,
+    let numpy handle conversion from an arbitrary iterator."""
+    import numpy as np
+
+    if _isscalar(arg):
+        arg = float(arg)
+        repeat = np.empty(size, dtype="float64")
+        repeat.fill(arg)
+        return repeat
+
+    else:
+        return np.require(arg, dtype="float64", requirements=["C"])
+
+
+def _char_array_argument(arg, size):
+    """Convert str or bytearray to bytes. If a single value is given and
+    size is not None, build a repeating byte array. Otherwise, let numpy
+    handle conversion from an arbitrary iterator."""
+
+    import numpy as np
+
+    # Convert to bytes first if possible. Single character case still
+    # needs to be handled after conversion.
+    if isinstance(arg, str):
+        arg = arg.encode()
+
+    if isinstance(arg, (bytes, bytearray)):
+        if size is not None and len(arg) == 1:
+            return arg * size
+        else:
+            return arg
+    else:
+        return np.require(arg, dtype="S1", requirements=["C"]).tobytes()
+
+
+def loadModel(
+    *,
+    env,
+    numvars,
+    numconstrs,
+    modelsense=GRB.MINIMIZE,
+    objcon=0.0,
+    obj=None,
+    lb=None,
+    ub=None,
+    vtype=None,
+    constr_csc=None,
+    sense=None,
+    rhs=None,
+    qobj_coo=None,
+    name=None,
+):
+    """
+    ROUTINE:
+      loadModel(
+        *, env, numvars, numconstrs, modelsense=GRB.MINIMIZE, objcon=0.0,
+        obj=None, lb=None, ub=None, vtype=None, constr_csc=None, sense=None,
+        rhs=None, qobj_coo=None, name=None
+      )
+
+    PURPOSE:
+      Create a new optimization model, using the provided arguments to
+      initialize the model data (objective function, variable bounds,
+      constraint matrix, etc.). The model is then ready for optimization.
+
+      This function allows you to build models with only linear constraints,
+      and linear or quadratic objectives.
+
+      You’ll need "numpy" installed to use this function. All arguments to
+      this function are keyword-only.
+
+    ARGUMENTS:
+      env – The environment in which the new model should be created.
+      numvars – The number of variables in the model.
+      numconstrs – The number of constraints in the model.
+      modelsense – The sense of the objective function. Allowed
+        values are "GRB.MINIMIZE" or "GRB.MAXIMIZE". Defaults to
+        "GRB.MINIMIZE".
+      objcon – Constant objective offset (defaults to "0.0").
+      obj – (optional) Objective coefficients for the model
+        variables, as a list or 1-D array of length "numvars". If not
+        provided, all linear objective coefficients in the model are set
+        to "0.0".
+      lb – (optional) Lower bounds for the model variables, as a
+        list or 1-D array of length "numvars". If not provided, all
+        variables will have lower bounds of "0.0".
+      ub – (optional) Upper bounds for the model variables, as a
+        list or 1-D array of length "numvars". If not provided, all
+        variables will have infinite upper bounds.
+      vtype – (optional) Types for the variables, as a list or 1-D
+        array of length "numvars". Options are "GRB.CONTINUOUS",
+        "GRB.BINARY", "GRB.INTEGER", "GRB.SEMICONT", or "GRB.SEMIINT". If
+        not provided, all variables will be continuous.
+      constr_csc – (optional) Linear constraint data in Compressed
+        Sparse Column format (CSC) as a tuple "(data, indices, indptr)".
+        In this format the constraint indices for variable i are stored
+        in "indices[indptr[i]:indptr[i+1]]" and their corresponding
+        coefficients are stored in "data[indptr[i]:indptr[i+1]]". The
+        format is the same as that used by "scipy.sparse.csc_array". This
+        argument can be omitted if no linear constraints are being added.
+      sense – (optional) The senses for the model constraints, as a
+        list or 1-D array of length "numconstrs". Options are
+        "GRB.EQUAL", "GRB.LESS_EQUAL", or "GRB.GREATER_EQUAL". Can be
+        omitted if no linear constraints are being added.
+      rhs – (optional) Right-hand side values for the new
+        constraints, as a list or 1-D array of length "numconstrs". Can
+        be omitted if no linear constraints are being added.
+      qobj_coo – (optional) Quadratic objective matrix in
+        coordinate format as a tuple "(qval, (qrow, qcol))". The i^{th}
+        quadratic term is represented using three values: a pair of
+        indices (stored in "qrow[i]" and "qcol[i]"), and a coefficient
+        (stored in "qval[i]"). The format is the same as that used by
+        "scipy.sparse.coo_array". This argument can be omitted if no
+        quadratic objective terms are being added.
+      name – (optional) The name of the model.
+
+    RETURN VALUE:
+      A Model object.
+    """
+
+    import numpy as np
+
+    if name is None:
+        modelname = b""
+    elif isinstance(name, str):
+        modelname = name.encode()
+    else:
+        raise TypeError("'modelname' must be a string or None")
+
+    try:
+        numvars = int(numvars)
+    except ValueError as e:
+        raise ValueError("'numvars' must be an integer") from e
+
+    try:
+        numconstrs = int(numconstrs)
+    except ValueError as e:
+        raise ValueError("'numconstrs' must be an integer") from e
+
+    if numvars < 0:
+        raise ValueError("'numvars' must be non-negative")
+    if numconstrs < 0:
+        raise ValueError("'numconstrs' must be non-negative")
+
+    try:
+        modelsense = int(modelsense)
+    except ValueError as e:
+        raise ValueError("'modelsense' must be an integer") from e
+
+    try:
+        objcon = float(objcon)
+    except ValueError as e:
+        raise ValueError("'objcon' must be numeric") from e
+
+    # Prepare variable attribute arrays, repeating scalars if needed
+    if obj is not None:
+        obj = _double_array_argument(obj, size=numvars)
+    if lb is not None:
+        lb = _double_array_argument(lb, size=numvars)
+    if ub is not None:
+        ub = _double_array_argument(ub, size=numvars)
+    if vtype is not None:
+        vtype = _char_array_argument(vtype, size=numvars)
+
+    if numconstrs == 0:
+        # No linear constraint matrix was given; construct an empty one
+        rhs = np.array([], dtype="float64")
+        sense = b""
+        vbeg = np.zeros((numvars,), dtype="uint64")
+        vlen = np.zeros((numvars,), dtype="int32")
+        vind = np.array([], dtype="int32")
+        vval = np.array([], dtype="float64")
+
+    else:
+        # To avoid ambiguity, a string for 'sense' must have length numconstrs.
+        # no '<=' or '<' allowed to set the same sense for all constraints.
+        sense = _char_array_argument(sense, size=None)
+
+        rhs = _double_array_argument(rhs, size=numconstrs)
+
+        try:
+            data, indices, indptr = constr_csc
+        except Exception as e:
+            raise ValueError(
+                "'constr_csc' must be a tuple of the form (data, indices, indptr)"
+            ) from e
+
+        vind = np.require(indices, dtype="int32", requirements=["C"])
+        vval = np.require(data, dtype="float64", requirements=["C"])
+
+        indptr = np.require(indptr, dtype="uint64", requirements=["C"])
+        vlen = np.empty(len(indptr) - 1, dtype="int32")
+        np.subtract(indptr[1:], indptr[:-1], out=vlen)
+        vbeg = indptr[:-1]
+
+    model = _load_model_memoryview(
+        env=env,
+        numvars=numvars,
+        numconstrs=numconstrs,
+        modelname=modelname,
+        objsense=modelsense,
+        objcon=objcon,
+        obj=obj,
+        sense=sense,
+        rhs=rhs,
+        vbeg=vbeg,
+        vlen=vlen,
+        vind=vind,
+        vval=vval,
+        lb=lb,
+        ub=ub,
+        vtype=vtype,
+    )
+
+    # Any further operations must be followed by an update() call. The model
+    # must be cleaned up if an exception is raised after this point.
+
+    if qobj_coo is not None:
+
+        try:
+            qval, (qrow, qcol) = qobj_coo
+        except Exception as e:
+            model.close()
+            raise ValueError(
+                "'qobj_coo' must be a tuple of the form (qval, (qrow, qcol))"
+            ) from e
+
+        try:
+            numqnz = len(qrow)
+            _add_qp_terms_memoryview(
+                model=model,
+                numqnz=numqnz,
+                qrow=np.require(qrow, dtype="int32", requirements=["C"]),
+                qcol=np.require(qcol, dtype="int32", requirements=["C"]),
+                qval=np.require(qval, dtype="float64", requirements=["C"]),
+            )
+            model.update()
+        except Exception:
+            model.close()
+            raise
+
+    return model