def solve(self, objective, constraints, cached_data, verbose, solver_opts):
"""Returns the result of the call to the solver.
Parameters
----------
objective : LinOp
The canonicalized objective.
constraints : list
The list of canonicalized cosntraints.
cached_data : dict
A map of solver name to cached problem data.
verbose : bool
Should the solver print output?
solver_opts : dict
Additional arguments for the solver.
Returns
-------
tuple
(status, optimal value, primal, equality dual, inequality dual)
"""
prob_data = self.get_problem_data(objective, constraints, cached_data)
dims = prob_data[0][-3] # TODO this is a hack.
obj_offset = prob_data[1]
# Save original cvxopt solver options.
old_options = cvxopt.solvers.options
# Silence cvxopt if verbose is False.
cvxopt.solvers.options['show_progress'] = verbose
# Always do one step of iterative refinement after solving KKT system.
cvxopt.solvers.options['refinement'] = 1
# Apply any user-specific options.
# Rename max_iters to maxiters.
if "max_iters" in solver_opts:
solver_opts["maxiters"] = solver_opts["max_iters"]
for key, value in list(solver_opts.items()):
cvxopt.solvers.options[key] = value
try:
# Target cvxopt clp if nonlinear constraints exist
if dims[s.EXP_DIM]:
_, F, G, _, dims, A, _ = prob_data[0]
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A, F)
results_dict = cvxopt.solvers.cpl(*prob_data[0],
kktsolver=kktsolver)
else:
_, G, _, dims, A, _ = prob_data[0]
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A)
results_dict = cvxopt.solvers.conelp(*prob_data[0],
kktsolver=kktsolver)
# Catch exceptions in CVXOPT and convert them to solver errors.
except ValueError:
results_dict = {'status': 'unknown'}
# Restore original cvxopt solver options.
cvxopt.solvers.options = old_options
return self.format_results(results_dict, dims, obj_offset)
def solve(self, objective, constraints, cached_data, verbose, solver_opts):
"""Returns the result of the call to the solver.
Parameters
----------
objective : LinOp
The canonicalized objective.
constraints : list
The list of canonicalized cosntraints.
cached_data : dict
A map of solver name to cached problem data.
verbose : bool
Should the solver print output?
solver_opts : dict
Additional arguments for the solver.
Returns
-------
tuple
(status, optimal value, primal, equality dual, inequality dual)
"""
prob_data = self.get_problem_data(objective, constraints, cached_data)
dims = prob_data[0][-3] # TODO this is a hack.
obj_offset = prob_data[1]
# Save original cvxopt solver options.
old_options = cvxopt.solvers.options
# Silence cvxopt if verbose is False.
cvxopt.solvers.options['show_progress'] = verbose
# Always do one step of iterative refinement after solving KKT system.
cvxopt.solvers.options['refinement'] = 1
# Apply any user-specific options.
# Rename max_iters to maxiters.
if "max_iters" in solver_opts:
solver_opts["maxiters"] = solver_opts["max_iters"]
for key, value in solver_opts.items():
cvxopt.solvers.options[key] = value
try:
# Target cvxopt clp if nonlinear constraints exist
if dims[s.EXP_DIM]:
_, F, G, _, dims, A, _ = prob_data[0]
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A, F)
results_dict = cvxopt.solvers.cpl(*prob_data[0],
kktsolver=kktsolver)
else:
_, G, _, dims, A, _ = prob_data[0]
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A)
results_dict = cvxopt.solvers.conelp(*prob_data[0],
kktsolver=kktsolver)
# Catch exceptions in CVXOPT and convert them to solver errors.
except ValueError:
results_dict = {'status': 'unknown'}
# Restore original cvxopt solver options.
cvxopt.solvers.options = old_options
return self.format_results(results_dict, dims, obj_offset)
def conelp_solve(self, data, kktsolver):
"""Solve using the conelp solver.
Parameters
----------
data : dict
All the problem data.
kktsolver : The kktsolver to use.
robust : Use the robust kktsolver?
Returns
-------
dict
The solver output.
Raises
------
ValueError
If CVXOPT fails.
"""
import cvxopt, cvxopt.solvers
if kktsolver == s.ROBUST_KKTSOLVER:
# Get custom kktsolver.
kktsolver = get_kktsolver(data[s.G],
data[s.DIMS],
data[s.A])
return cvxopt.solvers.conelp(data[s.C],
data[s.G],
data[s.H],
data[s.DIMS],
data[s.A],
data[s.B],
kktsolver=kktsolver)
def _cvxopt_solve(self, objective, constr_map, dims,
var_offsets, x_length,
verbose, opts):
"""Calls the CVXOPT conelp or cpl solver and returns the result.
Parameters
----------
objective: Expression
The canonicalized objective.
constr_map: dict
A dict of the canonicalized constraints.
dims: dict
A dict with information about the types of constraints.
sorted_vars: list
An ordered list of the problem variables.
var_offsets: dict
A dict mapping variable id to offset in the stacked variable x.
x_length: int
The height of x.
verbose: bool
Should the solver show output?
opts: dict
List of user-specific options for CVXOPT;
will be inserted into cvxopt.solvers.options.
Returns
-------
tuple
(status, optimal objective, optimal x,
optimal equality constraint dual,
optimal inequality constraint dual)
"""
prob_data = self._cvxopt_problem_data(objective, constr_map, dims,
var_offsets, x_length)
c, G, h, dims, A, b = prob_data[0]
obj_offset = prob_data[1]
# Save original cvxopt solver options.
old_options = cvxopt.solvers.options
# Silence cvxopt if verbose is False.
cvxopt.solvers.options['show_progress'] = verbose
# Always do one step of iterative refinement after solving KKT system.
cvxopt.solvers.options['refinement'] = 1
# Apply any user-specific options.
# Rename max_iters to maxiters.
if "max_iters" in opts:
opts["maxiters"] = opts["max_iters"]
for key, value in opts.items():
cvxopt.solvers.options[key] = value
try:
# Target cvxopt clp if nonlinear constraints exist
if constr_map[s.EXP]:
# Get the nonlinear constraints.
F = self._merge_nonlin(constr_map[s.EXP], var_offsets,
x_length)
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A, F)
results = cvxopt.solvers.cpl(c, F, G, h, dims, A, b,
kktsolver=kktsolver)
else:
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A)
results = cvxopt.solvers.conelp(c, G, h, dims, A, b,
kktsolver=kktsolver)
status = s.SOLVER_STATUS[s.CVXOPT][results['status']]
# Catch exceptions in CVXOPT and convert them to solver errors.
except ValueError as e:
status = s.SOLVER_ERROR
# Restore original cvxopt solver options.
cvxopt.solvers.options = old_options
if status in s.SOLUTION_PRESENT:
primal_val = results['primal objective']
value = self.objective._primal_to_result(
primal_val - obj_offset)
if constr_map[s.EXP]:
ineq_dual = results['zl']
else:
ineq_dual = results['z']
return (status, value, results['x'], results['y'], ineq_dual)
else:
return (status, None, None, None, None)
def _cvxopt_solve(self, objective, constr_map, dims, var_offsets, x_length,
verbose, opts):
"""Calls the CVXOPT conelp or cpl solver and returns the result.
Parameters
----------
objective: Expression
The canonicalized objective.
constr_map: dict
A dict of the canonicalized constraints.
dims: dict
A dict with information about the types of constraints.
sorted_vars: list
An ordered list of the problem variables.
var_offsets: dict
A dict mapping variable id to offset in the stacked variable x.
x_length: int
The height of x.
verbose: bool
Should the solver show output?
opts: dict
List of user-specific options for CVXOPT;
will be inserted into cvxopt.solvers.options.
Returns
-------
tuple
(status, optimal objective, optimal x,
optimal equality constraint dual,
optimal inequality constraint dual)
"""
prob_data = self._cvxopt_problem_data(objective, constr_map, dims,
var_offsets, x_length)
c, G, h, dims, A, b = prob_data[0]
obj_offset = prob_data[1]
# Save original cvxopt solver options.
old_options = cvxopt.solvers.options
# Silence cvxopt if verbose is False.
cvxopt.solvers.options['show_progress'] = verbose
# Always do one step of iterative refinement after solving KKT system.
cvxopt.solvers.options['refinement'] = 1
# Apply any user-specific options
for key, value in opts.items():
cvxopt.solvers.options[key] = value
# Target cvxopt clp if nonlinear constraints exist
if constr_map[s.EXP]:
# Get the nonlinear constraints.
F = self._merge_nonlin(constr_map[s.EXP], var_offsets, x_length)
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A, F)
results = cvxopt.solvers.cpl(c,
F,
G,
h,
dims,
A,
b,
kktsolver=kktsolver)
else:
# Get custom kktsolver.
kktsolver = get_kktsolver(G, dims, A)
results = cvxopt.solvers.conelp(c,
G,
h,
dims,
A,
b,
kktsolver=kktsolver)
# Restore original cvxopt solver options.
cvxopt.solvers.options = old_options
status = s.SOLVER_STATUS[s.CVXOPT][results['status']]
if status == s.OPTIMAL:
primal_val = results['primal objective']
value = self.objective._primal_to_result(primal_val - obj_offset)
if constr_map[s.EXP]:
ineq_dual = results['zl']
else:
ineq_dual = results['z']
return (status, value, results['x'], results['y'], ineq_dual)
else:
return (status, None, None, None, None)
def solve(self, objective, constraints, cached_data,
warm_start, verbose, solver_opts):
"""Returns the result of the call to the solver.
Parameters
----------
objective : LinOp
The canonicalized objective.
constraints : list
The list of canonicalized cosntraints.
cached_data : dict
A map of solver name to cached problem data.
warm_start : bool
Not used.
verbose : bool
Should the solver print output?
solver_opts : dict
Additional arguments for the solver.
Returns
-------
tuple
(status, optimal value, primal, equality dual, inequality dual)
"""
import cvxopt, cvxopt.solvers
data = self.get_problem_data(objective, constraints, cached_data)
# User chosen KKT solver option.
kktsolver = self.get_kktsolver_opt(solver_opts)
# Save original cvxopt solver options.
old_options = cvxopt.solvers.options.copy()
# Silence cvxopt if verbose is False.
cvxopt.solvers.options["show_progress"] = verbose
# Apply any user-specific options.
# Rename max_iters to maxiters.
if "max_iters" in solver_opts:
solver_opts["maxiters"] = solver_opts["max_iters"]
for key, value in solver_opts.items():
cvxopt.solvers.options[key] = value
# Always do 1 step of iterative refinement after solving KKT system.
if not "refinement" in cvxopt.solvers.options:
cvxopt.solvers.options["refinement"] = 1
try:
# Target cvxopt clp if nonlinear constraints exist.
if data[s.DIMS][s.EXP_DIM]:
if kktsolver is None:
# Get custom kktsolver.
kktsolver = get_kktsolver(data[s.G],
data[s.DIMS],
data[s.A],
data[s.F])
results_dict = cvxopt.solvers.cpl(data[s.C],
data[s.F],
data[s.G],
data[s.H],
data[s.DIMS],
data[s.A],
data[s.B],
kktsolver=kktsolver)
else:
if kktsolver is None:
# Get custom kktsolver.
kktsolver = get_kktsolver(data[s.G],
data[s.DIMS],
data[s.A])
results_dict = cvxopt.solvers.conelp(data[s.C],
data[s.G],
data[s.H],
data[s.DIMS],
data[s.A],
data[s.B],
kktsolver=kktsolver)
# Catch exceptions in CVXOPT and convert them to solver errors.
except ValueError:
results_dict = {"status": "unknown"}
# Restore original cvxopt solver options.
self._restore_solver_options(old_options)
return self.format_results(results_dict, data, cached_data)
def solve(self, objective, constraints, cached_data, warm_start, verbose,
solver_opts):
"""Returns the result of the call to the solver.
Parameters
----------
objective : LinOp
The canonicalized objective.
constraints : list
The list of canonicalized cosntraints.
cached_data : dict
A map of solver name to cached problem data.
warm_start : bool
Not used.
verbose : bool
Should the solver print output?
solver_opts : dict
Additional arguments for the solver.
Returns
-------
tuple
(status, optimal value, primal, equality dual, inequality dual)
"""
import cvxopt, cvxopt.solvers
data = self.get_problem_data(objective, constraints, cached_data)
# User chosen KKT solver option.
kktsolver = self.get_kktsolver_opt(solver_opts)
# Save original cvxopt solver options.
old_options = cvxopt.solvers.options
# Silence cvxopt if verbose is False.
cvxopt.solvers.options["show_progress"] = verbose
# Apply any user-specific options.
# Rename max_iters to maxiters.
if "max_iters" in solver_opts:
solver_opts["maxiters"] = solver_opts["max_iters"]
for key, value in solver_opts.items():
cvxopt.solvers.options[key] = value
# Always do 1 step of iterative refinement after solving KKT system.
if not "refinement" in cvxopt.solvers.options:
cvxopt.solvers.options["refinement"] = 1
try:
# Target cvxopt clp if nonlinear constraints exist
if data[s.DIMS][s.EXP_DIM]:
if kktsolver is None:
# Get custom kktsolver.
kktsolver = get_kktsolver(data[s.G], data[s.DIMS],
data[s.A], data[s.F])
results_dict = cvxopt.solvers.cpl(data[s.C],
data[s.F],
data[s.G],
data[s.H],
data[s.DIMS],
data[s.A],
data[s.B],
kktsolver=kktsolver)
else:
if kktsolver is None:
# Get custom kktsolver.
kktsolver = get_kktsolver(data[s.G], data[s.DIMS],
data[s.A])
results_dict = cvxopt.solvers.conelp(data[s.C],
data[s.G],
data[s.H],
data[s.DIMS],
data[s.A],
data[s.B],
kktsolver=kktsolver)
# Catch exceptions in CVXOPT and convert them to solver errors.
except ValueError:
results_dict = {"status": "unknown"}
# Restore original cvxopt solver options.
cvxopt.solvers.options = old_options
return self.format_results(results_dict, data[s.DIMS], data[s.OFFSET],
cached_data)
