def test_make_canonical_2(self):
self.tableau = tableau_2().get(optim="max")
t = Optimization._to_canonical(self.tableau.table,
self.tableau.base_var_indices)
tbl = PlainTableau(t, self.tableau.var_names, self.tableau._model_vars,
self.tableau.base_var_indices)
self.assertEqual(tbl.is_canonical(), True)
def test_example4(self):
t = self.t3.get()
tbl = PlainTableau(t.table,
var_names=self.var_names,
model_vars=['x_1', 'x_2'],
base_var_indices=[2, 3, 4])
res = tbl.var_result(only_model_vars=True)
# print(res)
self.assertEqual(VariableValues.from_dict({'x_1': 0, 'x_2': 0}), res)
def test_step(self):
t = self.t3.get()
# print(t)
t2, pp = Optimization.simplex_step(t.table)
res = PlainTableau(
t2,
var_names=self.var_names,
model_vars=['x_1', 'x_2'],
base_var_indices=[0, 2, 3]).var_result(only_model_vars=True)
self.assertEqual(VariableValues.from_dict({'x_1': 8.0, 'x_2': 0}), res)
def test_run_for_solution(self):
t = self.tb.get()
result_table, res_base_indices = Optimization(t)._full_simplex(
t.var_names, t.base_var_indices)
# Optimization.__init__(table). ...
tabl = PlainTableau(result_table,
var_names=["x1", "x2", "_s_1", "_s_2", "_a_1"],
model_vars=['x1', 'x2'],
base_var_indices=res_base_indices)
vv = tabl.var_result()
self.assertEqual(vv._as_dict(), {'_a_1': 0.5, 'x1': 1.0})
def test_step_3(self):
t = self.t3.get()
t2, pp = Optimization.simplex_step(t.table)
t3, pp = Optimization.simplex_step(t2)
t4, pp = Optimization.simplex_step(t3)
res = PlainTableau(
t4,
var_names=self.var_names,
model_vars=['x_1', 'x_2'],
base_var_indices=[0, 1, 4]).var_result(only_model_vars=True)
self.assertEqual(
VariableValues.from_dict({
'x_1': 2.9999999999999996,
'x_2': 12.0
}), res)
def run(self):
# INTIALIZE BASE SOLUTION (INDICES / COLUMN IN TABLE).
tableau = self._tableau
initial_solution = tableau.base_var_indices
try:
final_table, final_base = self._full_simplex(
tableau.var_names, initial_solution)
except UnboundedTableau:
return "unbounded", tableau.table
val = PlainTableau(
final_table,
var_names=tableau.var_names,
model_vars=tableau._model_vars,
base_var_indices=final_base).var_result(only_model_vars=True)
return val, final_table
def get(self, optim="max"):
constraint_idx_to_slack_var_idx, \
constraint_idx_to_artificial_idx, \
variable_descriptions = self.init_needed_variables()
vnames = [name for idx, name, _ in variable_descriptions]
base_var_idxs = []
for constraint_idx, c in enumerate(self.constraints):
# get slack variable (index) for constraint
slack_var_idx = constraint_idx_to_slack_var_idx[constraint_idx]
if isinstance(c, GreaterEqualThan): # add artificial variable.
artif_var_idx = constraint_idx_to_artificial_idx[
constraint_idx]
# add artifvar to initial base
base_var_idxs.append(artif_var_idx)
elif isinstance(c, LessEqualThan):
base_var_idxs.append(slack_var_idx)
artif_var_idx = None
else:
raise AttributeError
new_row = TableauBuilder._build_constraint(c, slack_var_idx,
artif_var_idx,
len(self._table[-1, :]))
self._table[constraint_idx, :] = new_row
bigm_indices = [
indx for indx, name, typ_ in variable_descriptions
if typ_ == "artificial"
]
self._table = TableauBuilder._build_objective(self._table,
self.objective,
bigm_indices, optim,
self._big_m_value)
return PlainTableau(
self._table,
var_names=vnames,
model_vars=[vnames[i] for i in range(self.no_vars)],
base_var_indices=base_var_idxs)
def test_variable_name(self):
t = self.t3.get()
res = PlainTableau(t.table, model_vars=['x_1',
'x_2']).get_variable_names()
self.assertEqual(['x1', 'x2'], res)