def build_dual_from_max_primal(self) -> LinearModel:
# Building FO
variables = []
fo_coefficients = [i[0] for i in self.primal.b]
fo_coefficients_variables = []
for index, c in enumerate(self.primal.constraints):
var = None
if c.equality_operator == '<=':
var = Variable(name='y{0}'.format(index + 1),
initial_index=index)
elif c.equality_operator == '>=':
var = Variable(name='y{0}'.format(index + 1),
initial_index=index,
constraint=VariableConstraint.Negative)
elif c.equality_operator == '=':
var = Variable(name='y{0}'.format(index + 1),
initial_index=index,
constraint=VariableConstraint.Unrestricted)
variables.append(var)
fo_coefficients_variables.append((fo_coefficients[index], var))
fo = ObjectiveFunction('min', fo_coefficients_variables)
# Building Constraints
constraints_inequalities = []
for v in self.primal.fo.variables:
if v.non_positive:
constraints_inequalities.append('<=')
elif v.free:
constraints_inequalities.append('=')
else:
constraints_inequalities.append('>=')
constraints = []
At = self.primal.A.transpose()
right_side = self.primal.fo.coefficients
_i = 0
for row in At:
const_coefficients_variables = []
for index, v in enumerate(variables):
const_coefficients_variables.append((row[index], v))
constraint = Constraint(
name='R{0}'.format(_i + 1),
coefficients_variables=const_coefficients_variables,
equality_operator=constraints_inequalities[_i],
right_side=right_side[_i])
constraints.append(constraint)
_i = _i + 1
return LinearModel(objective_function=fo,
constraints_list=constraints,
name=self.primal.name + '- Dual')
def CreateVariable(self, variableText):
name = variableText\
.split(" ")[0]\
.strip()
# maybe a bit overzealous, but I can see how [A, B, Alpha, Beta] makes sense
tuple = variableText\
.split(" ", 1)[-1]\
.replace("[", "")\
.replace("]", "")\
.strip()
if "," not in tuple:
tuple = tuple\
.replace(" ", ",")
evalTuple = eval(tuple)
return Variable(name, evalTuple)
min_step = min(steps_excluding_negative)
variable_leave_B_index = steps.index(min_step)
# Updating Base and Non Base
variable_leave_B = solver.B_variables[variable_leave_B_index]
variable_join_N = solver.N_variables[variable_join_N_index]
solver.B_variables[variable_leave_B_index] = variable_join_N
solver.N_variables[variable_join_N_index] = variable_leave_B
self.current_iteration = self.current_iteration + 1
self.__solve_lp__(__solver__=solver)
if __name__ == '__main__':
x1 = Variable(name='x1')
x2 = Variable(name='x2')
x3 = Variable(name='x3')
fo = ObjectiveFunction('min', [(1, x1), (-1, x2), (2, x3)])
c1 = Constraint([(1, x1), (1, x2), (1, x3)], '=', 3)
c2 = Constraint([(2, x1), (-1, x2), (3, x3)], '<=', 4)
model = LinearModel(objective_function=fo, constraints_list=[c1, c2])
p1 = Phase1(linear_model=model)
initial_base = p1.find_base()
p2 = Phase2(linear_model=model, base_indexes=p1.base_variables)
p2.solve()
print('Phase1 unit test passed')
def __init__(self, solver: SimplexSolver):
self.model = solver
self.A = solver.model.A
self.b = solver.model.b
self.fo_value = solver.fo_value
self.decision_variables = []
self.support_variables = []
self.variables = []
if any([type(i) == FreeVariable for i in solver.model.fo.variables]):
print(
'[WARNING]: We have found unrestricted variables. [Xi = Xip-Xin]. '
'\nXi values, are saved on .decision_variables. '
'\nXip and Xin, are saved on both .support_variables and .variables'
)
already_solved_free_vars = []
for index, v in enumerate(solver.model.fo.variables):
value = 0
if v.id in self.model.B_variables:
position_index = self.model.B_variables.index(v.id)
value = solver.xb[position_index][0]
# Free Variables
un_value = 0
if type(
v
) == FreeVariable and v.id not in already_solved_free_vars:
if v.positive:
un_value = solver.xb[position_index][0]
else:
un_value = -1 * solver.xb[position_index][0]
already_solved_free_vars.append(v.id)
for _v in solver.model.fo.variables:
if type(
_v
) == FreeVariable and _v.parent_index == v.parent_index and _v.id != v.id:
if _v in self.model.B_variables:
n_index = self.model.B_variables.index(_v.id)
if v.positive:
un_value = un_value + solver.xb[n_index][0]
else:
un_value = un_value - solver.xb[n_index][0]
already_solved_free_vars.append(_v.id)
decision_var = Variable(name='x{0}'.format(v.parent_index +
1),
initial_index=v.parent_index)
self.decision_variables.append((un_value, decision_var))
if type(v) == Variable: # Decision Variables
if v.non_positive:
print(
"[WARNING]: {0} is required to be non_positive, but solver only deals with positive values."
"\nThe solution value can be found in solution.decision_variables"
"\nThe solver value can be find in solution.variables".
format(v.name))
self.decision_variables.append((-1 * value, v))
else:
self.decision_variables.append((value, v))
else:
self.support_variables.append((value, v))
self.variables.append((value, v))
_i = 0
for row in At:
const_coefficients_variables = []
for index, v in enumerate(variables):
const_coefficients_variables.append((row[index], v))
constraint = Constraint(
name='R{0}'.format(_i + 1),
coefficients_variables=const_coefficients_variables,
equality_operator=constraints_inequalities[_i],
right_side=right_side[_i])
constraints.append(constraint)
_i = _i + 1
return LinearModel(objective_function=fo,
constraints_list=constraints,
name=self.primal.name + '- Dual')
if __name__ == '__main__':
x1 = Variable(name='x1')
x2 = Variable(name='x2', constraint=VariableConstraint.Unrestricted)
x3 = Variable(name='x3', constraint=VariableConstraint.Negative)
fo = ObjectiveFunction('max', [(1, x1), (2, x2), (0, x3)])
c1 = Constraint([(-2, x1), (1, x2), (1, x3)], '>=', 3)
c2 = Constraint([(3, x1), (4, x2)], '<=', 5)
primal = LinearModel(objective_function=fo, constraints_list=[c1, c2])
dual_transformation = DualTransformation(primal=primal)
dual = dual_transformation.dual
print('Dual unit test passed')
@property
def b(self):
_b = np.zeros(shape=(self.m, 1))
for index, c in enumerate(self.constraints):
_b[index] = c.right_side
return _b
def __repr__(self):
m = '\nModel {0}:\n'.format(self.name)
m = m + 'min Fo(x)= '
for index, v in enumerate(self.fo.variables):
m = m + str(self.fo.coefficients[index]) + '*' + str(v) + ' '
m = m + '\n\n'
for r in self.constraints:
m = m + str(r) + '\n'
return m
if __name__ == '__main__':
x1 = Variable(name='x1')
x2 = Variable(name='x2', negative=True)
x3 = Variable(name='x3', free=True)
x4 = Variable(name='x4', free=True)
fo = ObjectiveFunction('max', [(3, x1), (2, x2), (-1, x3), (1, x4)])
c1 = Constraint([(1, x1), (2, x2), (1, x3), (-1, x4)], '<=', 5)
c2 = Constraint([(-2, x1), (-4, x2), (1, x3), (1, x4)], '<=', -1)
model = LinearModel(objective_function=fo, constraints_list=[c1, c2])
model.standard_form()
print('Linear Model unit test passed')
raise TypeError("Coefficient must be a number")
if not isinstance(v, Variable):
raise TypeError("Variable must be a Variable() object")
self.coefficients.append(c)
self.variables.append(v)
def __repr__(self):
f_rep = '{0}:'.format(self.name)
for index, c in enumerate(self.coefficients):
if c >= 0:
f_rep = f_rep + ' + {0}*{1}'.format(
str(c), self.variables[index].internal_name)
else:
f_rep = f_rep + ' {0}*{1}'.format(
str(c), self.variables[index].internal_name)
f_rep = f_rep + ' {0} {1}'.format(self.equality_operator,
self.right_side)
return f_rep
if __name__ == '__main__':
x1 = Variable()
x2 = Variable()
x3 = Variable()
fo = ObjectiveFunction('min', [(1, x1), (2, x2)])
c1 = Constraint([(-1, x1), (-2, x2)], '>=', -4)
print('Function unit test passed')
from models.variable import Variable, VariableConstraint
from models.function import ObjectiveFunction, Constraint
from models.linear_model import LinearModel
from models.solver import LinearSolver
# Problem setup Branch and Bound
x1 = Variable(name='x1', integer=True)
x2 = Variable(name='x2', integer=True)
fo = ObjectiveFunction('max', [(3, x1), (5, x2)])
c1 = Constraint([(2, x1), (4, x2)], '<=', 25)
c2 = Constraint([(1, x1)], '<=', 8)
c3 = Constraint([(2, x2)], '<=', 10)
model = LinearModel(objective_function=fo, constraints_list=[c1, c2, c3])
solver = LinearSolver(linear_model=model)
print(solver.best_solution)
"""
# Problem setup (Branch and Bound with degeneracy
x1 = Variable(name='x1', integer=True)
x2 = Variable(name='x2', integer=True)
fo = ObjectiveFunction('max', [(3, x1), (7, x2)])
c1 = Constraint([(1, x1)], '<=', 3.5)
c2 = Constraint([(5, x1), (-4, x2)], '<=', 10)
c3 = Constraint([(4/7, x1), (2, x2)], '<=', 9)
model = LinearModel(objective_function=fo, constraints_list=[c1, c2, c3])
solver = LinearSolver(linear_model=model)
print(solver.best_solution)
"""
