def direction(self, value):
if getattr(self, 'problem', None) is not None:
glp_set_obj_dir(self.problem.problem, {
'min': GLP_MIN,
'max': GLP_MAX
}[value])
super(Objective, Objective).direction.__set__(self, value)
def set_objective_sense(self, sense):
"""Set type of problem (maximize or minimize)."""
if sense not in (ObjectiveSense.Minimize, ObjectiveSense.Maximize):
raise ValueError('Invalid objective sense')
swiglpk.glp_set_obj_dir(self._p, self.OBJ_SENSE_MAP[sense])
def set_objective_sense(self, sense):
"""Set type of problem (maximize or minimize)."""
if sense not in (ObjectiveSense.Minimize, ObjectiveSense.Maximize):
raise ValueError('Invalid objective sense')
swiglpk.glp_set_obj_dir(self._p, self.OBJ_SENSE_MAP[sense])
def objective(self, value):
value.problem = None
if self._objective is not None:
for variable in self.objective.variables:
if variable.index is not None:
glp_set_obj_coef(self.problem, variable.index, 0.)
super(Model, self.__class__).objective.fset(self, value)
self.update()
expression = self._objective._expression
if isinstance(expression, float) or isinstance(expression, int) or expression.is_Number:
pass
else:
if expression.is_Symbol:
glp_set_obj_coef(self.problem, expression.index, 1.)
if expression.is_Mul:
coeff, var = expression.args
glp_set_obj_coef(self.problem, var.index, float(coeff))
elif expression.is_Add:
for term in expression.args:
coeff, var = term.args
glp_set_obj_coef(self.problem, var.index, float(coeff))
else:
raise ValueError(
"Provided objective %s doesn't seem to be appropriate." %
self._objective)
glp_set_obj_dir(
self.problem,
{'min': GLP_MIN, 'max': GLP_MAX}[self._objective.direction]
)
value.problem = self
def _solve(self):
if self._solved:
return
if self._maximize:
glp.glp_set_obj_dir(self._lp, glp.GLP_MAX)
else:
glp.glp_set_obj_dir(self._lp, glp.GLP_MIN)
result = glp.glp_simplex(self._lp, self._smcp)
# If no solution within iteration limit, switch to dual method to find solution
if result == glp.GLP_EITLIM:
print(
'Warning: could not find solution with primal method, switching to dual'
)
self.simplex_method = SimplexMethod.DUALP
result = glp.glp_simplex(self._lp, self._smcp)
self.simplex_method = SimplexMethod.PRIMAL
if result != 0:
raise RuntimeError(
SIMPLEX_RETURN_CODE_TO_STRING.get(
result, "GLP_?: UNKNOWN SOLVER RETURN VALUE"))
if self.status_code != glp.GLP_OPT:
raise RuntimeError(self.status_string)
self._solved = True
def test_swiglpk(self): """Test the underlying GLPK lib and its SWIG interface based on the example from https://github.com/biosustain/swiglpk """ ia = glp.intArray(1 + 1000) ja = glp.intArray(1 + 1000) ar = glp.doubleArray(1 + 1000) lp = glp.glp_create_prob() smcp = glp.glp_smcp() glp.glp_init_smcp(smcp) smcp.msg_lev = glp.GLP_MSG_ALL # use GLP_MSG_ERR? glp.glp_set_prob_name(lp, "sample") glp.glp_set_obj_dir(lp, glp.GLP_MAX) glp.glp_add_rows(lp, 3) glp.glp_set_row_name(lp, 1, "p") glp.glp_set_row_bnds(lp, 1, glp.GLP_UP, 0.0, 100.0) glp.glp_set_row_name(lp, 2, "q") glp.glp_set_row_bnds(lp, 2, glp.GLP_UP, 0.0, 600.0) glp.glp_set_row_name(lp, 3, "r") glp.glp_set_row_bnds(lp, 3, glp.GLP_UP, 0.0, 300.0) glp.glp_add_cols(lp, 3) glp.glp_set_col_name(lp, 1, "x1") glp.glp_set_col_bnds(lp, 1, glp.GLP_LO, 0.0, 0.0) glp.glp_set_obj_coef(lp, 1, 10.0) glp.glp_set_col_name(lp, 2, "x2") glp.glp_set_col_bnds(lp, 2, glp.GLP_LO, 0.0, 0.0) glp.glp_set_obj_coef(lp, 2, 6.0) glp.glp_set_col_name(lp, 3, "x3") glp.glp_set_col_bnds(lp, 3, glp.GLP_LO, 0.0, 0.0) glp.glp_set_obj_coef(lp, 3, 4.0) ia[1] = 1; ja[1] = 1; ar[1] = 1.0 # a[1,1] = 1 ia[2] = 1; ja[2] = 2; ar[2] = 1.0 # a[1,2] = 1 ia[3] = 1; ja[3] = 3; ar[3] = 1.0 # a[1,3] = 1 ia[4] = 2; ja[4] = 1; ar[4] = 10.0 # a[2,1] = 10 ia[5] = 3; ja[5] = 1; ar[5] = 2.0 # a[3,1] = 2 ia[6] = 2; ja[6] = 2; ar[6] = 4.0 # a[2,2] = 4 ia[7] = 3; ja[7] = 2; ar[7] = 2.0 # a[3,2] = 2 ia[8] = 2; ja[8] = 3; ar[8] = 5.0 # a[2,3] = 5 ia[9] = 3; ja[9] = 3; ar[9] = 6.0 # a[3,3] = 6 glp.glp_load_matrix(lp, 9, ia, ja, ar) glp.glp_simplex(lp, smcp) Z = glp.glp_get_obj_val(lp) x1 = glp.glp_get_col_prim(lp, 1) x2 = glp.glp_get_col_prim(lp, 2) x3 = glp.glp_get_col_prim(lp, 3) self.assertAlmostEqual(Z, 733.3333, 4) self.assertAlmostEqual(x1, 33.3333, 4) self.assertAlmostEqual(x2, 66.6667, 4) self.assertAlmostEqual(x3, 0) glp.glp_delete_prob(lp)
def _linprog(c, A, b, obj):
lp = glpk.glp_create_prob()
glpk.glp_set_obj_dir(lp, obj)
params = glpk.glp_smcp()
glpk.glp_init_smcp(params)
params.msg_lev = glpk.GLP_MSG_OFF #Only print error messages from GLPK
num_rows = A.shape[0]
num_cols = A.shape[1]
mat_size = num_rows * num_cols
glpk.glp_add_rows(lp, num_rows)
for row_ind in range(num_rows):
glpk.glp_set_row_bnds(lp, row_ind + 1, glpk.GLP_UP, 0.0,
float(b[row_ind]))
glpk.glp_add_cols(lp, num_cols)
for col_ind in range(num_cols):
glpk.glp_set_col_bnds(lp, col_ind + 1, glpk.GLP_FR, 0.0, 0.0)
glpk.glp_set_obj_coef(lp, col_ind + 1, c[col_ind])
'Swig arrays are used for feeding constraints in GLPK'
ia, ja, ar = [], [], []
for i, j in product(range(num_rows), range(num_cols)):
ia.append(i + 1)
ja.append(j + 1)
ar.append(float(A[i][j]))
ia = glpk.as_intArray(ia)
ja = glpk.as_intArray(ja)
ar = glpk.as_doubleArray(ar)
glpk.glp_load_matrix(lp, mat_size, ia, ja, ar)
glpk.glp_simplex(lp, params)
fun = glpk.glp_get_obj_val(lp)
x = [
i for i in map(lambda x: glpk.glp_get_col_prim(lp, x + 1),
range(num_cols))
]
glpk.glp_delete_prob(lp)
glpk.glp_free_env()
return LPSolution(x, fun)
def setup_linprog(
recipes: Dict[str, 'Recipe'],
min_rates: Optional[Dict[str, float]] = None,
min_clocks: Optional[Dict[str, int]] = None,
fixed_clocks: Optional[Dict[str, int]] = None,
) -> SwigPyObject:
if min_rates is None:
min_rates = {}
if min_clocks is None:
min_clocks = {}
if fixed_clocks is None:
fixed_clocks = {}
resources = sorted({p for r in recipes.values() for p in r.rates.keys()})
resource_indices: Dict[str,
int] = {r: i
for i, r in enumerate(resources, 1)}
m = len(resources)
n = len(recipes)
problem: SwigPyObject = lp.glp_create_prob()
lp.glp_set_prob_name(problem, 'satisfactory')
lp.glp_set_obj_name(problem, 'percentage_sum')
lp.glp_set_obj_dir(problem, lp.GLP_MIN)
lp.glp_add_rows(problem, m)
lp.glp_add_cols(problem, n)
for i, resource in enumerate(resources, 1):
setup_row(problem, i, resource, min_rates.get(resource, 0))
for j, recipe in enumerate(recipes.values(), 1):
setup_col(
problem,
j,
recipe,
resource_indices,
min_clocks.get(recipe.name),
fixed_clocks.get(recipe.name),
)
lp.glp_create_index(problem)
return problem
def objective(self, value):
value.problem = None
if self._objective is not None:
variables = self.objective.variables
for variable in variables:
if variable._index is not None:
glp_set_obj_coef(self.problem, variable._index, 0.)
super(Model, self.__class__).objective.fset(self, value)
self.update()
coef_dict, _ = parse_optimization_expression(value, linear=True)
for var, coef in coef_dict.items():
glp_set_obj_coef(self.problem, var._index, float(coef))
glp_set_obj_dir(self.problem, {
'min': GLP_MIN,
'max': GLP_MAX
}[self._objective.direction])
value.problem = self
def objective(self, value):
value.problem = None
if self._objective is not None:
variables = self.objective.variables
for variable in variables:
if variable._index is not None:
glp_set_obj_coef(self.problem, variable._index, 0.)
super(Model, self.__class__).objective.fset(self, value)
self.update()
coef_dict, _ = parse_optimization_expression(value, linear=True)
for var, coef in coef_dict.items():
glp_set_obj_coef(self.problem, var._index, float(coef))
glp_set_obj_dir(
self.problem,
{'min': GLP_MIN, 'max': GLP_MAX}[self._objective.direction]
)
value.problem = self
def _solve(self):
if self._solved:
return
if self._maximize:
glp.glp_set_obj_dir(self._lp, glp.GLP_MAX)
else:
glp.glp_set_obj_dir(self._lp, glp.GLP_MIN)
result = glp.glp_simplex(self._lp, self._smcp)
# Adjust solver options for robustness
## If no solution within iteration limit, switch to dual method to find solution
if result == glp.GLP_EITLIM:
print(
'Warning: could not find solution with primal method, switching to dual'
)
self.simplex_method = SimplexMethod.DUALP
result = glp.glp_simplex(self._lp, self._smcp)
self.simplex_method = SimplexMethod.PRIMAL
## If still no solution, presolve the problem to reduce complexity
## (also prevents warm start)
if self.status_code != glp.GLP_OPT:
print(
'Warning: could not find solution with dual method, using primal with presolve'
)
self._smcp.presolve = glp.GLP_ON
result = glp.glp_simplex(self._lp, self._smcp)
self._smcp.presolve = glp.GLP_OFF
if result != 0:
raise RuntimeError(
SIMPLEX_RETURN_CODE_TO_STRING.get(
result, "GLP_?: UNKNOWN SOLVER RETURN VALUE"))
if self.status_code != glp.GLP_OPT:
raise RuntimeError(self.status_string)
self._solved = True
def _import_problem(self):
import swiglpk as glpk
if self.verbosity() >= 1:
glpk.glp_term_out(glpk.GLP_ON)
else:
glpk.glp_term_out(glpk.GLP_OFF)
# Create a problem instance.
p = self.int = glpk.glp_create_prob();
# Set the objective.
if self.ext.objective[0] in ("find", "min"):
glpk.glp_set_obj_dir(p, glpk.GLP_MIN)
elif self.ext.objective[0] is "max":
glpk.glp_set_obj_dir(p, glpk.GLP_MAX)
else:
raise NotImplementedError("Objective '{0}' not supported by GLPK."
.format(self.ext.objective[0]))
# Set objective function shift
if self.ext.objective[1] is not None \
and self.ext.objective[1].constant is not None:
if not isinstance(self.ext.objective[1], AffinExp):
raise NotImplementedError("Non-linear objective function not "
"supported by GLPK.")
if self.ext.objective[1].constant.size != (1,1):
raise NotImplementedError("Non-scalar objective function not "
"supported by GLPK.")
glpk.glp_set_obj_coef(p, 0, self.ext.objective[1].constant[0])
# Add variables.
# Multideminsional variables are split into multiple scalar variables
# represented as matrix columns within GLPK.
for varName in self.ext.varNames:
var = self.ext.variables[varName]
# Add a column for every scalar variable.
numCols = var.size[0] * var.size[1]
glpk.glp_add_cols(p, numCols)
for localIndex, picosIndex \
in enumerate(range(var.startIndex, var.endIndex)):
glpkIndex = self._picos2glpk_variable_index(picosIndex)
# Assign a name to the scalar variable.
scalarName = varName
if numCols > 1:
x = localIndex // var.size[0]
y = localIndex % var.size[0]
scalarName += "_{:d}_{:d}".format(x + 1, y + 1)
glpk.glp_set_col_name(p, glpkIndex, scalarName)
# Assign bounds to the scalar variable.
lower, upper = var.bnd.get(localIndex, (None, None))
if lower is not None and upper is not None:
if lower == upper:
glpk.glp_set_col_bnds(
p, glpkIndex, glpk.GLP_FX, lower, upper)
else:
glpk.glp_set_col_bnds(
p, glpkIndex, glpk.GLP_DB, lower, upper)
elif lower is not None and upper is None:
glpk.glp_set_col_bnds(p, glpkIndex, glpk.GLP_LO, lower, 0)
elif lower is None and upper is not None:
glpk.glp_set_col_bnds(p, glpkIndex, glpk.GLP_UP, 0, upper)
else:
glpk.glp_set_col_bnds(p, glpkIndex, glpk.GLP_FR, 0, 0)
# Assign a type to the scalar variable.
if var.vtype in ("continuous", "symmetric"):
glpk.glp_set_col_kind(p, glpkIndex, glpk.GLP_CV)
elif var.vtype == "integer":
glpk.glp_set_col_kind(p, glpkIndex, glpk.GLP_IV)
elif var.vtype == "binary":
glpk.glp_set_col_kind(p, glpkIndex, glpk.GLP_BV)
else:
raise NotImplementedError("Variable type '{0}' not "
"supported by GLPK.".format(var.vtype()))
# Set objective function coefficient of the scalar variable.
if self.ext.objective[1] is not None \
and var in self.ext.objective[1].factors:
glpk.glp_set_obj_coef(p, glpkIndex,
self.ext.objective[1].factors[var][localIndex])
# Add constraints.
# Multideminsional constraints are split into multiple scalar
# constraints represented as matrix rows within GLPK.
rowOffset = 1
for constraintNum, constraint in enumerate(self.ext.constraints):
if not isinstance(constraint, AffineConstraint):
raise NotImplementedError(
"Non-linear constraints not supported by GLPK.")
# Add a row for every scalar constraint.
# Internally, GLPK uses an auxiliary variable for every such row,
# bounded by the right hand side of the scalar constraint in a
# canonical form.
numRows = len(constraint)
glpk.glp_add_rows(p, numRows)
self._debug("Handling PICOS Constraint: " + str(constraint))
# Split multidimensional constraints into multiple scalar ones.
for localConIndex, (glpkVarIndices, coefficients, rhs) in \
enumerate(constraint.sparse_Ab_rows(
None, indexFunction = lambda picosVar, i:
self._picos2glpk_variable_index(picosVar.startIndex + i))):
# Determine GLPK's row index of the scalar constraint.
glpkConIndex = rowOffset + localConIndex
numColumns = len(glpkVarIndices)
# Name the auxiliary variable associated with the current row.
if constraint.name:
name = constraint.name
else:
name = "rhs_{:d}".format(constraintNum)
if numRows > 1:
x = localConIndex // constraint.size[0]
y = localConIndex % constraint.size[0]
name += "_{:d}_{:d}".format(x + 1, y + 1)
glpk.glp_set_row_name(p, glpkConIndex, name)
# Assign bounds to the auxiliary variable.
if constraint.is_equality():
glpk.glp_set_row_bnds(p, glpkConIndex, glpk.GLP_FX, rhs,rhs)
elif constraint.is_increasing():
glpk.glp_set_row_bnds(p, glpkConIndex, glpk.GLP_UP, 0, rhs)
elif constraint.is_decreasing():
glpk.glp_set_row_bnds(p, glpkConIndex, glpk.GLP_LO, rhs, 0)
else:
assert False, "Unexpected constraint relation."
# Set coefficients for current row.
# Note that GLPK requires a glpk.intArray containing column
# indices and a glpk.doubleArray of same size containing the
# coefficients for the listed column index. The first element
# of both arrays (with index 0) is skipped by GLPK.
glpkVarIndicesArray = glpk.intArray(numColumns + 1)
for i in range(numColumns):
glpkVarIndicesArray[i + 1] = glpkVarIndices[i]
coefficientsArray = glpk.doubleArray(numColumns + 1)
for i in range(numColumns):
coefficientsArray[i + 1] = coefficients[i]
glpk.glp_set_mat_row(p, glpkConIndex, numColumns,
glpkVarIndicesArray, coefficientsArray)
rowOffset += numRows
def direction(self, value):
if getattr(self, 'problem', None) is not None:
glp_set_obj_dir(self.problem.problem, {'min': GLP_MIN, 'max': GLP_MAX}[value])
super(Objective, Objective).direction.__set__(self, value)
def create_minimization_problem():
glpk.glp_term_out(glpk.GLP_OFF)
lp = glpk.glp_create_prob()
glpk.glp_set_obj_dir(lp, glpk.GLP_MIN)
return lp
