import pulp

# Ingresamos algunos datos del problema

emp_E1 = 6 # Numero de empleados en la estacion E1
emp_E2 = 8 # Numero de empleados en la estacion E2
horas_TR = 8 # Numero de horas en un turno regular
horas_TE = 4 # Maximo numero de horas extra por empleado
costo_HR = 6.00 # Costo de una hora de trabajo regular
costo_HE = 8.50 # Costo de una hora de trabajo extra

# Construirmos un objeto que representa un programa lineal

prob = pulp.LpProblem( 'Tarea_04_Problema_01', pulp.LpMaximize)

# Construimos las variables de decision

x_1 = pulp.LpVariable( 'x_1', 0, None, pulp.LpInteger) # Blusas B1 a ser
producidas
x_2 = pulp.LpVariable( 'x_2', 0, None, pulp.LpInteger) # Blusas B2 a ser
producidas
x_3 = pulp.LpVariable( 'x_3', 0, None, pulp.LpInteger) # Blusas B3 a ser
producidas
x_4 = pulp.LpVariable( 'x_4', 0, None, pulp.LpInteger) # Blusas B4 a ser
producidas
# Numero de horas extra a ser contratadas para la estacion E1
y_1 = pulp.LpVariable( 'y_1', 0, emp_E1 * horas_TE, pulp.LpInteger)
# Numero de horas extra a ser contratadas para la estacion E2
y_2 = pulp.LpVariable( 'y_2', 0, emp_E2 * horas_TE, pulp.LpInteger)

# Ingresamos las restricciones

prob += (1/8) * x_2 + (1/7) * x_3 + (1/9) * x_4 <= \
( emp_E1 * horas_TR ) + y_1, 'Capacidad_de_la_Estacion_E1'

prob += (1/9) * x_1 + (1/6) * x_2 + (1/10) * x_3 + (1/7) * x_4 <= \
( emp_E2 * horas_TR ) + y_2, 'Capacidad_de_la_Estacion_E2'
prob += (1/8) * x_1 + (1/9) * x_3 + (1/11) * x_4 <= 3 * 24
'Capacidad_de_la_Estacion_E3'

# Declaramos la funcion de utilidad

prob += 12 * x_1 + 22 * x_2 + 15 * x_3 + 20 * x_4 \
- costo_HR * horas_TR * ( emp_E1 + emp_E2 ) - costo_HE * ( y_1 + y_2 )

# Imprimimos al terminal el PL
print(prob)

# Ordenamos al objeto que representa el PL que lo solucione

prob.solve()

# Imprimimos al terminal el estado de la solucion

print( 'Estado (en ingles):', pulp.LpStatus[prob.status])

# Iteramos sobre las variables de decision del problema, imprimiendo al

terminal
# el valor optimo de cada variable
print( 'Valores optimos de las variables de decision:')
for var in prob.variables() :
# Imprimimos al terminal el nombre de la variable de decision, seguido
del simbolo igual,
# y del valor optimo de la variable
print( var.name, '=', var.varValue)

# Imprimimos al terminal la utilidad optima

print( 'Utilidad_Optima =', pulp.value(prob.objective) )

"""
Tarea 04, Problema 02: Problema de la Cooperativa de Pescadores.
@author: Luis I. Reyes Castro
"""

# Importamos el modulo para programacion lineal

import pulp

# Ingresamos algunos datos del problema

demanda
= [ 550, 800, 850, 600, 850, 750 ] # Kg de pescado
demandados
disp
puerto
precio

= [ 3.8, 4.4, 4.8, 4.0, 3.6, 3.2 ] # Tons de pescado disponibles en el

= [ 36/D for D in disp ] # Precio del kg de pescado (en dolares)

cap_refri = 160 # Capacidad de las refrigeradoras de la cooperativa (en

kg)

# Construirmos un objeto que representa un programa lineal

prob = pulp.LpProblem( 'Tarea_04_Problema_02', pulp.LpMinimize)

# Construimos una lista de 6 variables de decision de compra

x = [ pulp.LpVariable( 'x_' + str(k+1), 0, disp[k] * 1000) for k in range(0,6) ]
# Construimos una lista de 5 variables de decision de almacenamiento
# en las refrigeradoras de la cooperativa
y = [ pulp.LpVariable( 'y_' + str(k+1), 0, cap_refri) for k in range(0,5) ]
# Construimos una lista de 5 variables de decision de almacenamiento
# en las camaras frigorificas
z = [ pulp.LpVariable( 'z_' + str(k+1), 0) for k in range(0,5) ]

# Ingresamos la restriccion asociada con la Semana 01

prob += x[0] == demanda[0] + y[0] + z[0],
'Restriccion_para_la_Semana_01'
# Ingresamos las restricciones asociadas con las Semanas 02-05
for k in range(1,5):
prob += x[k] + y[k-1] + z[k-1] == demanda[k] + y[k] + z[k], \
'Restriccion_para_la_Semana_' + str(k+1).zfill(2)
# Ingresamos la restriccion asociada con la Semana 06
prob += x[-1] + y[-1] + z[-1] == demanda[-1],
'Restriccion_para_la_Semana_06'

# Declaramos la funcion de costo

prob += pulp.lpSum( precio[k] * x[k] for k in range(0,6) ) + \
0.25 * pulp.lpSum( y[k] for k in range(0,5) ) + \
0.60 * pulp.lpSum( z[k] for k in range(0,5) )

# Imprimimos al terminal el PL
print(prob)

# Ordenamos al objeto que representa el PL que lo solucione

prob.solve()

# Imprimimos al terminal el estado de la solucion

print( 'Estado (en ingles):', pulp.LpStatus[prob.status])

# Iteramos sobre las variables de decision del problema, imprimiendo al

terminal
# el valor optimo de cada variable
print( 'Valores optimos de las variables de decision:')
for var in prob.variables() :

print( var.name, '=', var.varValue)

# Imprimimos al terminal el costo optimo

print( 'Costo_Optimo =', pulp.value(prob.objective) )

"""
Tarea 04, Problema 03: Problema de la Concesionaria CarroCosta (Parte II).
@author: Luis I. Reyes Castro
"""

# Importamos el modulo para programacion lineal

import pulp

# Ingresamos algunos datos del problema

demanda = [ 44, 28, 32, 44, 56, 72, 46, 34, 50, 48, 82, 64] # Numeros de
vehiculos demandados
costo_alquilar = 25 # Costo por estacionamiento
costo_aumentar = 50 # Costo por cada estacionamiento adicional
solicitado
costo_liberar = 35 # Costo por cada estacionamiento liberado

# Construirmos un objeto que representa un programa lineal

prob = pulp.LpProblem( 'Tarea_04_Problema_03', pulp.LpMinimize)

# Construimos una lista de variables de decision de

importacion/desaduanizacion
x = [ pulp.LpVariable( 'x_' + str(k).zfill(2), 0, 60, pulp.LpInteger) for k in
range(1,13) ]
# Construimos una lista de variables de decision de inventario

s = [ pulp.LpVariable( 's_' + str(k).zfill(2), 0, None, pulp.LpInteger) for k in

range(1,12) ]
# Construimos una lista de variables de decision de alquiler de
estacionamientos
y = [ pulp.LpVariable( 'y_' + str(k).zfill(2), 0, None, pulp.LpInteger) for k in
range(1,12) ]
# Construimos una lista de variables de decision de solictud de
estacionamientos adicionales
y_AR = [ pulp.LpVariable( 'y_AR_' + str(k).zfill(2), 0, None, pulp.LpInteger)
for k in range(1,13) ]
# Construimos una lista de variables de decision de liberacion de
estacionamientos
y_AB = [ pulp.LpVariable( 'y_AB_' + str(k).zfill(2), 0, None, pulp.LpInteger)
for k in range(1,13) ]

# Ingresamos las restricciones por importancion e inventario de vehiculos

# Mes 01:
prob += x[0] == s[0] + demanda[0], 'Restriccion_de_ImportacionInventario_del_Mes_01'
# Mes 02-11:
for k in range(1,11):
prob += x[k] + s[k-1] == demanda[k] + s[k], \
'Restriccion_de_Importacion-Inventario_del_Mes_' + str(k+1).zfill(2)
# Mes 12:
prob += x[-1] + s[-1] == demanda[-1], 'Restriccion_de_ImportacionInventario_del_Mes_12'

# Ingresamos las restricciones por estacionamientos requeridos

for k in range(0,11):
prob += y[k] >= s[k], \
'Restriccion_de_Inventario-Estacionamiento_del_Mes_' + str(k+1).zfill(2)

# Ingresamos las restricciones de aumento o disminucion de

estacionamientos
# Mes 01:
prob += y[0] == y_AR[0], 'Restriccion_de_AumentoLiberacion_de_Estacionamientos_del_Mes_01'
# Meses 02-11:
for k in range(1,11):
prob += y[k] == y[k-1] + y_AR[k] - y_AB[k], \
'Restriccion_de_Aumento-Liberacion_de_Estacionamientos_del_Mes_' +
str(k+1).zfill(2)
# Mes 12:
prob += 0 == y[10] - y_AB[11], \
'Restriccion_de_Aumento-Liberacion_de_Estacionamientos_del_Mes_12'

# Declaramos la funcion de costo

prob += costo_alquilar * pulp.lpSum( y[k] for k in range(0,11) ) + \
costo_aumentar * pulp.lpSum( y_AR[k] for k in range(0,12) ) + \
costo_liberar * pulp.lpSum( y_AB[k] for k in range(0,12) )

# Imprimimos al terminal el PL
print(prob)

# Ordenamos al objeto que representa el PL que lo solucione

prob.solve()

# Imprimimos al terminal el estado de la solucion

print( 'Estado (en ingles):', pulp.LpStatus[prob.status])

# Iteramos sobre las variables de decision del problema, imprimiendo al

terminal

# el valor optimo de cada variable

print( 'Valores optimos de las variables de decision:')
for var in prob.variables() :
print( var.name, '=', var.varValue)

# Imprimimos al terminal el costo optimo

print( 'Costo_Optimo =', pulp.value(prob.objective) )

"""
Tarea 04, Problema 04: Problema de Inversion Multiperiodo con Banco
Extrangero.
@author: Luis I. Reyes Castro

NOTA: Para este problema no se exigio el uso de lazos de repeticion, y por

ende no hay
penalidad por declarar todas las variables y restricciones explicitamente. Yo
utilice
diccionarios y lazos de repeticion para declarar las variables de decision
facilmente,
pero hacer esto no era obligatorio.
"""

# Importamos el modulo para programacion lineal

import pulp

# Ingresamos algunos datos del problema:

# Monto inicial (i.e. monto a ser invertido en el primer anyo)
m_ini = 2.4 * 10**6
# Montos a ser invertidos al comienzo de los primeros ocho anyos del
horizonte

m_inv = { 1: m_ini, 2: m_ini, 3: 1.05 * m_ini, 4: 1.05 * m_ini, \

5: (1.05**2) * m_ini, 6: (1.05**2) * m_ini, \
7: (1.05**3) * m_ini, 8: (1.05**3) * m_ini }

# Construirmos un objeto que representa un programa lineal

prob = pulp.LpProblem( 'Tarea_04_Problema_04', pulp.LpMaximize)

# Construimos un diccionario de variables de compra de bonos de Corp. El

Celeste
x = { k : pulp.LpVariable( 'x_' + str(k), 0, None, pulp.LpInteger) for k in
range(1,8) }
# Construimos un diccionario de variables de compra de bonos de Corp. La
Preferida
y = { k : pulp.LpVariable( 'y_' + str(k), 0, None, pulp.LpInteger) for k in
range(1,7) }
# Construimos un diccionario de variables de compra de bonos de TMA
z = { k : pulp.LpVariable( 'z_' + str(k), 0, None, pulp.LpInteger) for k in
range(1,5) }
# Construimos un diccionario de variables de montos en la cuenta de
ahorros
w = { k : pulp.LpVariable( 'w_' + str(k), 0) for k in range(1,9) }
# Construimos un diccionario de variables de depositos a la cuenta de
ahorros
w_dep = { k : pulp.LpVariable( 'w_dep_' + str(k), 0) for k in range(1,9) }
# Construimos un diccionario de variables de retiros de la cuenta de ahorros
w_ret = { k : pulp.LpVariable( 'w_ret_' + str(k), 0) for k in range(2,10) }
# Construimos la variable de decision de retorno final
r = pulp.LpVariable( 'r', 0)

# Ingresamos las restricciones de igualdad de ingresos-egresos

prob += m_inv[1] == 88.50 * x[1] + 102.80 * y[1] + 96.20 * z[1] + 1.05 *
w_dep[1], \

'Ingresos-Egresos_en_el_Anyo_01'
prob += m_inv[2] + 6 * y[1] + 2 * z[1] + w_ret[2] == \
88.50 * x[2] + 102.80 * y[2] + 96.20 * z[2] + 1.05 * w_dep[2], \
'Ingresos-Egresos_en_el_Anyo_02'
prob += m_inv[3] + 100 * x[1] + 6 * ( y[1] + y[2] ) + 2 * ( z[1] + z[2] ) +
w_ret[3] == \
88.50 * x[3] + 102.80 * y[3] + 96.20 * z[3] + 1.05 * w_dep[3], \
'Ingresos-Egresos_en_el_Anyo_03'
prob += m_inv[4] + 100 * x[2] + 106 * y[1] + 6 * ( y[2] + y[3] ) + \
4 * z[1] + 2 * ( z[2] + z[3] ) + w_ret[4] == \
88.50 * x[4] + 102.80 * y[4] + 96.20 * z[4] + 1.05 * w_dep[4], \
'Ingresos-Egresos_en_el_Anyo_04'
prob += m_inv[5] + 100 * x[3] + 106 * y[2] + 6 * ( y[3] + y[4] ) + \
4 * ( z[1] + z[2] ) + 2 * ( z[3] + z[4] ) + w_ret[5] == \
88.50 * x[5] + 102.80 * y[5] + 1.05 * w_dep[5], \
'Ingresos-Gastos_en_el_Anyo_05'
prob += m_inv[6] + 100 * x[4] + 106 * y[3] + 6 * ( y[4] + y[5] ) + \
104 * z[1] + 4 * ( z[2] + z[3] ) + 2 * z[4] + w_ret[6] == \
88.50 * x[6] + 102.80 * y[6] + 1.05 * w_dep[6], \
'Ingresos-Gastos_en_el_Anyo_06'
prob += m_inv[7] + 100 * x[5] + 106 * y[4] + 6 * ( y[5] + y[6] ) + \
104 * z[2] + 4 * ( z[3] + z[4] ) + w_ret[7] == 88.50 * x[7] + 1.05 *
w_dep[7], \
'Ingresos-Gastos_en_el_Anyo_07'
prob += m_inv[8] + 100 * x[6] + 106 * y[5] + 6 * y[6] + \
104 * z[3] + 4 * z[4] + w_ret[8] == 1.05 * w_dep[8], \
'Ingresos-Gastos_en_el_Anyo_08'
prob += 100 * x[7] + 106 * y[6] + 104 * z[4] + w_ret[9] == r, \
'Ingresos-Gastos_en_el_Anyo_09'

# Declaramos las restricciones asociadas con la cuenta de ahorros

for k in range(1,10):
prob += w.get( k, 0) == \
1.035 * w.get( k-1, 0) + w_dep.get( k, 0) - 1.02 * w_ret.get( k, 0), \
'Depositos-Retiros_en_el_Anyo_' + str(k).zfill(2)

# Declaramos la funcion de utilidad

prob += r

# Imprimimos al terminal el PL
print(prob)

# Ordenamos al objeto que representa el PL que lo solucione

prob.solve()

# Imprimimos al terminal el estado de la solucion

print( 'Estado (en ingles):', pulp.LpStatus[prob.status])

# Iteramos sobre las variables de decision del problema, imprimiendo al

terminal
# el valor optimo de cada variable
print( 'Valores optimos de las variables de decision:')
for var in prob.variables() :
# Imprimimos al terminal el nombre de la variable de decision, seguido
del simbolo igual,
# y del valor optimo de la variable
print( var.name, '=', var.varValue)

# Imprimimos al terminal la utilidad optima

print( 'Utilidad_Optima =', pulp.value(prob.objective) )