def __init__(self, **kwargs):
configure_glpk()
#
# Call base constructor
#
kwargs['type'] = 'glpk'
SystemCallSolver.__init__(self, **kwargs)
self._rawfile = None
#
# Valid problem formats, and valid results for each format
#
self._valid_problem_formats = [
ProblemFormat.cpxlp, ProblemFormat.mps, ProblemFormat.mod
]
self._valid_result_formats = {
ProblemFormat.mod: ResultsFormat.soln,
ProblemFormat.cpxlp: ResultsFormat.soln,
ProblemFormat.mps: ResultsFormat.soln,
}
self.set_problem_format(ProblemFormat.cpxlp)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
def __init__ (self, **kwargs):
configure_glpk()
#
# Call base constructor
#
kwargs['type'] = 'glpk'
SystemCallSolver.__init__(self, **kwargs)
self._rawfile = None
#
# Valid problem formats, and valid results for each format
#
self._valid_problem_formats = [ProblemFormat.cpxlp,
ProblemFormat.mps,
ProblemFormat.mod]
self._valid_result_formats = {
ProblemFormat.mod: ResultsFormat.soln,
ProblemFormat.cpxlp: ResultsFormat.soln,
ProblemFormat.mps: ResultsFormat.soln,
}
self.set_problem_format(ProblemFormat.cpxlp)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
def __init__(self, **kwds):
#
# Call base constructor
#
if not 'type' in kwds:
kwds["type"] = "asl"
SystemCallSolver.__init__(self, **kwds)
self._metasolver = True
#
# Setup valid problem formats, and valid results for each problem format.
# Also set the default problem and results formats.
#
self._valid_problem_formats = [ProblemFormat.nl]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self.set_problem_format(ProblemFormat.nl)
#
# Note: Undefined capabilities default to 'None'
#
self._capabilities = Bunch()
self._capabilities.linear = True
self._capabilities.integer = True
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.sos1 = True
self._capabilities.sos2 = True
def __init__(self, **kwds):
#
# Call base class constructor
#
kwds['type'] = 'baron'
SystemCallSolver.__init__(self, **kwds)
self._tim_file = None
self._valid_problem_formats = [ProblemFormat.bar]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.bar] = [ResultsFormat.soln]
self.set_problem_format(ProblemFormat.bar)
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.quadratic_objective = True
self._capabilities.quadratic_constraint = True
self._capabilities.integer = True
self._capabilities.sos1 = False
self._capabilities.sos2 = False
# CLH: Coppied from cpxlp.py, the cplex file writer.
# Keven Hunter made a nice point about using %.16g in his attachment
# to ticket #4319. I am adjusting this to %.17g as this mocks the
# behavior of using %r (i.e., float('%r'%<number>) == <number>) with
# the added benefit of outputting (+/-). The only case where this
# fails to mock the behavior of %r is for large (long) integers (L),
# which is a rare case to run into and is probably indicative of
# other issues with the model.
# *** NOTE ***: If you use 'r' or 's' here, it will break code that
# relies on using '%+' before the formatting character
# and you will need to go add extra logic to output
# the number's sign.
self._precision_string = '.17g'
def __init__(self, **kwds):
kwds["type"] = "neos"
SystemCallSolver.__init__(self, **kwds)
self._valid_problem_formats = [ProblemFormat.nl]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self._problem_format = ProblemFormat.nl
self._results_format = ResultsFormat.sol
def test_set_executable_isexe_nopath(self):
with SystemCallSolver(type='test') as opt:
self.assertEqual(id(opt._user_executable), id(None))
# because it is not in the PATH
with self.assertRaises(ValueError):
opt.set_executable(isexe_nopath)
self.assertEqual(id(opt._user_executable), id(None))
opt.set_executable(isexe_nopath, validate=False)
self.assertEqual(opt._user_executable, isexe_nopath)
self.assertEqual(opt.executable(), isexe_nopath)
opt._user_executable = None
# now add the exedir to the PATH
rm_PATH = False
orig_PATH = None
if "PATH" in os.environ:
orig_PATH = os.environ["PATH"]
else:
rm_PATH = True
os.environ["PATH"] = ""
os.environ["PATH"] = exedir + os.pathsep + os.environ["PATH"]
try:
opt.set_executable(isexe_nopath)
self.assertEqual(opt._user_executable, isexe_abspath)
self.assertEqual(opt.executable(), isexe_abspath)
finally:
if rm_PATH:
del os.environ["PATH"]
else:
os.environ["PATH"] = orig_PATH
def test_available(self):
with SystemCallSolver(type='test') as opt:
self.assertEqual(id(opt._user_executable), id(None))
# both cases should fail because this class is only
# a partial implementation
with self.assertRaises(ApplicationError):
opt.available(exception_flag=True)
def _presolve(self, *args, **kwds):
if (not isinstance(args[0], six.string_types)) and \
(not isinstance(args[0], IBlock)):
self._instance = args[0]
xfrm = TransformationFactory('mpec.nl')
xfrm.apply_to(self._instance)
if len(self._instance._transformation_data['mpec.nl'].compl_cuids) == 0:
# There were no complementarity conditions
# so we don't hold onto the instance
self._instance = None
else:
args = (self._instance,)
else:
self._instance = None
#
SystemCallSolver._presolve(self, *args, **kwds)
def test_set_executable_notexe_abspath_user(self):
with SystemCallSolver(type='test') as opt:
self.assertEqual(id(opt._user_executable), id(None))
with self.assertRaises(ValueError):
opt.set_executable(notexe_abspath_user)
self.assertEqual(id(opt._user_executable), id(None))
opt.set_executable(notexe_abspath_user, validate=False)
self.assertEqual(opt._user_executable, notexe_abspath_user)
self.assertEqual(opt.executable(), notexe_abspath_user)
def test_set_executable_isexe_abspath_user(self):
with SystemCallSolver(type='test') as opt:
self.assertEqual(id(opt._user_executable), id(None))
opt.set_executable(isexe_abspath_user)
self.assertEqual(opt._user_executable, isexe_abspath)
self.assertEqual(opt.executable(), isexe_abspath)
opt._user_executable = None
opt.set_executable(isexe_abspath_user, validate=False)
self.assertEqual(opt._user_executable, isexe_abspath_user)
self.assertEqual(opt.executable(), isexe_abspath_user)
def test_reset_executable(self):
with SystemCallSolver(type='test') as opt:
self.assertEqual(id(opt._user_executable), id(None))
with self.assertRaises(NotImplementedError):
opt.set_executable()
opt._user_executable = 'x'
opt.set_executable(validate=False)
self.assertEqual(id(opt._user_executable), id(None))
with self.assertRaises(NotImplementedError):
opt.executable()
def __init__(self, **kwds):
#
# Call base constructor
#
kwds["type"] = "pico"
SystemCallSolver.__init__(self, **kwds)
#
# Setup valid problem formats, and valid results for each problem format
#
self._valid_problem_formats=[ProblemFormat.cpxlp, ProblemFormat.nl, ProblemFormat.mps]
self._valid_result_formats = {}
self._valid_result_formats[ProblemFormat.cpxlp] = [ResultsFormat.soln]
self._valid_result_formats[ProblemFormat.nl] = [ResultsFormat.sol]
self._valid_result_formats[ProblemFormat.mps] = [ResultsFormat.soln]
self.set_problem_format(ProblemFormat.cpxlp)
# Note: Undefined capabilities default to 'None'
self._capabilities = Options()
self._capabilities.linear = True
self._capabilities.integer = True
def _postsolve(self):
#
# Reclassify complementarity components
#
mpec=False
if not self._instance is None:
from pyomo.mpec import Complementarity
for cuid in self._instance._transformation_data['mpec.nl'].compl_cuids:
mpec=True
cobj = cuid.find_component_on(self._instance)
cobj.parent_block().reclassify_component_type(cobj, Complementarity)
#
self._instance = None
return SystemCallSolver._postsolve(self)
def test_noexe(self):
with SystemCallSolver(type='test') as opt:
self.assertEqual(id(opt._user_executable), id(None))
with self.assertRaises(NotImplementedError):
opt.executable()
