Modelo de programación lineal del problema de transporte

"""
1. Creamos un objeto de la clase MILP. 
2. El parámetro maximization se iguala con False porque queremos minimizar. 
3. La variable envio guardará la información de todas las unidades enviadas. 
"""
programa = MixedIntegerLinearProgram(maximization=False)
envio = programa.new_variable(nonnegative=True, integer=True, name="Unidades Enviadas")

"""
1. Creamos un marco de datos con la información de las concesionarias.
2. Para cada clave de una concesionaria, asignamos el costo del envío desde la planta correspondiente. 
"""
import pandas as pd

costos = pd.DataFrame({
    'plantas' : ['sal', 'sil', 'her'],
    'mty': [100, 160, 200],
    'gdl': [213, 140, 230], 
    'gto': [180, 50, 310],
    'pue': [250, 200, 350]
})
costos = costos.set_index(['plantas'])
print(costos)

"""
1. Guardamos las claves de las plantas en una lista del mismo nombre.
"""
plantas = costos.index
print(plantas)

"""
1. Hacemos lo mismo con las concesionarias. 
"""
concesionarias = costos.columns
print(concesionarias)

"""
1. Ahora definiramos la función objetivo.
2. Sumaremos los costos de envío de planta a concesionaria.
"""
objetivo = 0

for p in plantas:
    for c in concesionarias:
        costo = costos[c].loc[p]
        print(p, c, costo)
        objetivo = objetivo+costo*envio[p,c]
        
programa.set_objective(objetivo)

"""
1. Antes de continuar, capturamos la capacidad de producción de cada planta. 
"""
capacidad = {
    'sal': 150, 'sil':250, 'her':100
}

capacidad = pd.Series(capacidad, dtype='float')
print(capacidad)

"""
1. Capturamos las resticciones de la producción de cada planta. 
2. En este caso supondremos que la producción total se envía a las diferentes concecionarias. 
3. La producción no puede sobrepasar a la capacidad. 
"""
for p in plantas:
    produccion = 0
    for c in concesionarias:
        produccion = produccion + envio[p, c]
    programa.add_constraint(produccion<=capacidad[p])    

"""
1. Capturamos la demanda por concesionaria.
"""
demanda = {
    'mty': 50, 'gdl':200, 'gto':100, 'pue':150
}

demanda = pd.Series(demanda, dtype='float')
print(demanda)

"""
1. Ahora capturamos la cantidad de autos enviados desde cada planta a una concesionaria dada.
2. La cantidad de autos enviados, en principio, debería ser mayor o igual que la demanda.
"""
for c in concesionarias:
    autos_enviados = 0
    for p in plantas:
        autos_enviados = autos_enviados+envio[p,c]
    programa.add_constraint(autos_enviados>=demanda[c])

"""
1. Imprimimos en pantalla la información del sistema para cotejar que es correcta.
"""
programa.show()

"""
1. Resolvemos el problema.
2. El valor resultante será el costo mínimo.
"""
programa.solve()

"""
1. También es de nuestro interés saber como asignar los autos de una planta a una consecionaria. 
2. El siguiente método nos indica como debemos de realizar los envío.
"""
programa.get_values(envio)

"""
1. Repetiremos algunos pasos adaptadolos al problema actual.
2. Primero capturamos los costos de las plantas a los almacenes.
"""
import pandas as pd

costos_1 = {
    'plantas': ['sal', 'sil', 'her'],
    'slp': [40,30,200],
    'edo': [200,80,250]
}

costos_1 = pd.DataFrame(costos_1)
costos_1 = costos_1.set_index('plantas')
costos_1

"""
1. Posteriormente, capturamos los costos de los almacenes a las concesionarias.
"""
costos_2 = {
    'almacenes': ['slp', 'edo'], 
    'mty': [50, 80], 
    'gdl': [30, 80],
    'gto': [60, 60], 
    'pue': [80, 40]
}

costos_2 = pd.DataFrame(costos_2)
costos_2 = costos_2.set_index("almacenes")
costos_2

"""
1. Creamos un programa de clase MILP
2. Declaramos la variable unidades, que representará cualquier tipo de unidad enviada entre nodos. 
3. Además declaramos la variable inventario, que representará el número de unidades que deben pasar por cada almacén. 
"""
programa = MixedIntegerLinearProgram(maximization=False)
unidades = programa.new_variable(nonnegative=True, integer=True, name="Unidades Enviadas")
inventario = programa.new_variable(nonnegative=True, integer=True, name="Unidades Almacenadas")

"""
1. Capturamos la lista de plantas.
"""
plantas = costos_1.index
print(plantas)

"""
1. Ahora la de contenedores.
"""
almacenes = costos_2.index
almacenes

"""
1. Finalmente la de concesionaria.
"""
concesionarias = costos_2.columns
concesionarias

"""
1. En este modelos, capturaremos la función objetivo en dos etapas. 
2. En la primera, agregaremos los costos planta -> almacén.
"""
objetivo = 0

for origen in plantas:
    for destino in almacenes:
        costo = costos_1[destino].loc[origen]
        print(origen, destino, costo)
        objetivo = objetivo+costo*unidades[origen,destino]

"""
1. En la segunda etapa, agregaremos los costos almacén -> concesionaria
"""
for origen in almacenes:
    for destino in concesionarias:
        costo = costos_2[destino].loc[origen]
        print(origen, destino, costo)
        objetivo = objetivo+costo*unidades[origen, destino]

"""
1. Ahora fijamos la función objetivo. 
"""
programa.set_objective(objetivo)
programa.show()

"""
1. Capturaremos las resticciones de capacidad de las plantas de manera similar al programa anterior.
"""
for planta in plantas:
    produccion = 0
    for almacen in almacenes:
        produccion = produccion + unidades[planta, almacen]
    programa.add_constraint(produccion<=capacidad[planta])

"""
1. Sin embargo, ahora los autos enviados desde las plantas deberán igualar el inventario de los almacenes. 
2. Recuerda que esta es una cantidad desconocida y por tanto usaremos una variable. 
"""
for almacen in almacenes:
    autos_enviados = 0
    for planta in plantas:
        autos_enviados = autos_enviados+unidades[planta,almacen]
    programa.add_constraint(autos_enviados==inventario[almacen])

"""
1. Ahora capturamos las restricciones de envío desde los almacenes. 
2. Puedes pensar que los almacenes "producen" unidades, tal como lo hacen las plantas en la etapa anterior. 
3. Solo recuerda que la capacidad total de envío de los almacenes no debe superar el inventario. 
"""
for almacen in almacenes:
    produccion = 0
    for concesionaria in concesionarias:
        produccion = produccion + unidades[almacen, concesionaria]
    programa.add_constraint(produccion<=inventario[almacen])

"""
1. Capturamos el envío de autos desde los almacenes a las concesionarias. 
2. Esto es similar al envío que se realizaba desde las plantas en el problema anterior. 
"""
for concesionaria in concesionarias:
    autos_enviados = 0
    for almacen in almacenes:
        autos_enviados = autos_enviados+unidades[almacen, concesionaria]
    programa.add_constraint(autos_enviados>=demanda[concesionaria])

"""
1. Imprimimos el programa en pantalla para verificar que todo sea correcto.
"""
programa.show()

"""
1. Finalmente resolvemos el problema.
2. El valor impreso en pantalla corresponderá con el costo mínimo. 
"""
programa.solve()

"""
1. En esta versión del problema de transporte, tennemos dos variables. 
2. Primero extraemos la información sobre los inventarios que se deben tener en cada almacén. 
"""
programa.get_values(inventario)

"""
1. Finalmente, extraemos la información de las unidades que se deben enviar entre cada nodo.
2. Los envíos son tanto para planta->almacén como almacén->concesionaria. 
"""
programa.get_values(unidades)