def defineObjectives(data: DataInstance, model: Model, boolVars, N, posVars):
LAG, RAG, TAG, BAG = boolVars
L, R, T, B, H, W = posVars
maxX = model.addVar(vtype=GRB.INTEGER, name="maxX")
maxY = model.addVar(vtype=GRB.INTEGER, name="maxY")
for element in range(data.element_count):
model.addConstr(maxX >= R[element])
model.addConstr(maxY >= B[element])
OBJECTIVE_GRIDCOUNT = LinExpr(0.0)
for element in range(data.element_count):
OBJECTIVE_GRIDCOUNT.addTerms([1.0, 1.0], [LAG[element], TAG[element]])
OBJECTIVE_GRIDCOUNT.addTerms([1.0, 1.0], [BAG[element], RAG[element]])
OBJECTIVE_LT = LinExpr(0)
for element in range(data.element_count):
OBJECTIVE_LT.addTerms([1, 1, 2, 2, -1, -1],
[T[element], L[element], B[element], R[element], W[element], H[element]])
Objective = LinExpr(0)
Objective.add(OBJECTIVE_GRIDCOUNT, 1)
Objective.add(OBJECTIVE_LT, 0.001)
# Objective.add(maxX, 10)
# Objective.add(maxY, 10)
model.addConstr(OBJECTIVE_GRIDCOUNT >= (calculateLowerBound(N)))
model.setObjective(Objective, GRB.MINIMIZE)
return OBJECTIVE_GRIDCOUNT, OBJECTIVE_LT
def criar_funcao_objetivo(model, lista_variaveis, variables, lista_coef):
# inicializando a expressão com a primeira variável
linear_expression = LinExpr()
for i in range(1, len(lista_variaveis)):
linear_expression.add(variables.values()[i], lista_coef[i])
model.setObjective(linear_expression, GRB.MINIMIZE)
return model
def _set_objective(self, objective):
expr = LinExpr()
for elem in objective.expr:
var = self.problem.getVarByName(elem.name)
expr.add(var, elem.coefficient)
self.problem.setObjective(expr, objective.sense)
def _add_constraint(self, const):
lhs = LinExpr()
for elem in const.lhs:
var = self.problem.getVarByName(elem.name)
lhs.add(var, elem.coefficient)
self.problem.addConstr(lhs, const.sense, const.rhs, const.name)
def equationBuilder(index_inequacao, model_vars):
index_inequacao.reverse()
sinal = '+'
expr = LinExpr()
for i in range(0, len(index_inequacao)):
if sinal == '+':
var = model_vars[index_inequacao[i]]
# adicionar variavel a expressao
expr.add(var, 1)
# alterar sinal
sinal = '-'
elif sinal == '-':
var = model_vars[index_inequacao[i]]
# adicionar variavel a expressao
expr.add(var, -1)
# alterar sinal
sinal = '+'
return expr
# obtendo a lista de variaveis e respectivos coeficientes para função
# obj.
lista_variaveis = df['nome_variavel']
lista_coeficientes = df['coeff']
# CRIANDO AS VARIÁVEIS DO MODELO ------------------------------------------
# variables = adicionar_variaveis_modelo(m, lista_variaveis,
# "modelo_var")
variables = m.addVars(lista_variaveis, vtype=GRB.BINARY, name="variables")
# ADICIONANDO EXPRESSÃO LINEAR DA FUNÇÃO OBJETIVO -------------------------
# inicializando a expressão com a primeira variável
linear_expression = LinExpr()
for i in range(1, len(lista_variaveis)):
linear_expression.add(variables.values()[i], lista_coeficientes[i])
m.setObjective(linear_expression, GRB.MINIMIZE)
# ADICIONANDO EXPRESSÃO LINEAR DA PRIMEIRA RESTRIÇÃO ------------------
# Garantindo que todos os vértices sejam pintados.
for numero_vertice in map(int, obter_lista_vertices(path)):
# Abaixo, obtendo indices das variáveis do vertice N, que devem ser
# somados em uma restrição linear para garantir que assumam
# apenas uma
# cor. Nesse caso, itero por cada vertice X de cor 'qualquer', para
# posteriomente somar todos quando construo a restrição.
lista_temp = [
r[0] for r in [i.lower().split('_') for i in lista_variaveis]
]
indices = [
n for n, l in enumerate(lista_temp)
import gurobipy as gp
from gurobipy import GRB
from gurobipy.gurobipy import LinExpr
# Create a new model
m = gp.Model("mip1")
# Create the set of variables
lista_variaveis = ['x', 'y', 'z']
vertices = m.addVars(lista_variaveis, vtype=GRB.BINARY, name="lista_variaveis")
# FO: Maximize the linear expression
# x + y + 2 z
expr = LinExpr([1], [vertices['x']])
expr.add(vertices['y'], 1)
expr.add(vertices['z'], 2)
m.setObjective(expr, GRB.MAXIMIZE)
# (outra maneira de passar o mesmo código acima, seria:
# expr = LinExpr([1, 1, 2], [vertices['x'],
# vertices['y'],
# vertices['z']])
# Adding contraints
# Add constraint: x + 2 y + 3 z <= 4
expr = LinExpr([1], [vertices['x']])
expr.add(vertices['y'], 2)
expr.add(vertices['z'], 3)
m.addConstr(expr, "<=", 4)
# (outra maneira de passar o mesmo código acima, seria:
#expr = LinExpr([1, 2, 3], [vertices['x'],
# vertices['y'],
# obtendo a lista de variaveis e respectivos coeficientes para função
# obj.
lista_variaveis = df['nome_variavel']
lista_coeficientes = df['coeff']
# CRIANDO AS VARIÁVEIS DO MODELO ------------------------------------------
# variables = adicionar_variaveis_modelo(m, lista_variaveis,
# "modelo_var")
variables = m.addVars(lista_variaveis, vtype=GRB.BINARY, name="variables")
# ADICIONANDO EXPRESSÃO LINEAR DA FUNÇÃO OBJETIVO -------------------------
# inicializando a expressão com a primeira variável
linear_expression = LinExpr()
for i in range(1, len(lista_variaveis)):
linear_expression.add(variables.values()[i], lista_coeficientes[i])
m.setObjective(linear_expression, GRB.MINIMIZE)
# ADICIONANDO EXPRESSÃO LINEAR DA PRIMEIRA RESTRIÇÃO ------------------
# Garantindo que todos os vértices sejam pintados.
for numero_vertice in map(int, obter_lista_vertices(path)):
# Abaixo, obtendo indices das variáveis do vertice N, que devem ser
# somados em uma restrição linear para garantir que assumam
# apenas uma
# cor. Nesse caso, itero por cada vertice X de cor 'qualquer', para
# posteriomente somar todos quando construo a restrição.
lista_temp = [
r[0] for r in [i.lower().split('_') for i in lista_variaveis]
]
indices = [
n for n, l in enumerate(lista_temp)
