En artículos anteriores hemos mencionado la diferencia existente entre programación lineal (PL) y programación lineal entera (PLE). Recordamos entonces que, cuando un modelo presenta todas sus variables enteras, se denomina puro. En caso contrario, cuando utiliza una combinación de variables enteras y continuas, se denomina mixto, constituyendo un modelo de programación lineal mixta.

En materia de optimización lineal, la programación lineal mixta, lógicamente, aborda la mayor cantidad de casos de aplicación práctica. En la medida en que se consideren la mayor cantidad de variables que representen mediante un modelo de optimización, la realidad; es potencialmente adecuado, hacer uso de modelos de programación mixta.

Por ejemplo, pensemos en la producción de televisores, es posible que en un modelo lineal queramos representar por medio de una variable entera, la cantidad de unidades producidas; ahora bien, también es posible que queramos representar por medio de una variable continua, el tiempo empleado en la fabricación. En este escenario, requerimos de programación lineal mixta.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar problemas de programación lineal mixta (optimización lineal mixta). 

OR-Tools proporciona una herramienta principal para resolver este tipo de problemas de optimización:

El problema

En el artículo de introducción (programación lineal), abordamos un caso descrito en el libro Applied Mathematical Programming, de Bradley, Hax, and Magnanti (Addison-Wesley, 1977), del MIT (Cápitulo 2 página 50). Con fines prácticos, hemos adaptado dicho problema, incorporando nuevas restricciones y modificando algunos datos del modelo original, con el propósito de evidenciar la diferencia en los resultados obtenidos por medio del uso de variables continuas, enteras y mixtas.

El propietario de una tienda que produce remolques para automóviles desea determinar la mejor combinación para sus tres productos: remolques de plataforma plana, remolques económicos y remolques de lujo. Su taller se limita a trabajar 24 días al mes en el trabajo de los metales y 60 días al mes en el trabajo de la madera para estos productos.

Existe un contrato vigente, mediante el cual, el propietario deberá entregar como mínimo 4 remolques tipo económico cada mes.

La siguiente tabla indica los datos de producción de los remolques.

Modelamiento del problema

Sean las variables de decisión del problema:

x₀ = Número de remolques de plataforma plana producidos por mes

x₁ = Número de remolques económicos producidos por mes

x₂ = Número de remolques de lujo producidos por mes

Suponiendo que los costos de la capacidad de trabajo en metal y madera sean fijos, el problema se convierte en un problema de maximización:

Zmax = 6x₀ + 14x₁ + 13x₂

Sujeto a las siguientes restricciones de capacidad:

0,6x₀ + 2x₁ + x₂ <= 24,

x₀ + 2x₁ + 4x₂ <= 60,

Sujeto a la siguiente restricción de demanda mínima (contrato)

x₁ >= 4

Sujeto a las siguientes restricciones de no-negatividad:

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

Podemos, del mismo modo, establecer un par de variables que correspondan a las horas ociosas para las dos tareas establecidas (metal y madera):

x₃ = Número de horas ociosas en el trabajo en metal al mes,

x₄ = Número de horas ociosas en el trabajo en madera al mes,

Reescribimos las restricciones (adicionando las variables de horas ociosas). Podemos observar que las inecuaciones ahora serán igualdades, para que de esta forma ahora podamos tener información relacionada a los recursos. En otras palabras, lo que se utiliza (horas productivas) + lo que sobre (horas ociosas) = tiempo disponible:

0,6x₀ + 2x₁ + x₂ + x₃ = 24,

x₀ + 2x₁ + 4x₂ + x₄ = 60,

x₀ >= 0,

x₁ >= 0,

x₂ >= 0,

x₃ >= 0,

x₄ >= 0,

Así entonces, tenemos el problema completamente modelado.

Resolución del modelo mediante Google OR-Tools

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, en esta ocasión, haremos uso del lenguaje de programación Python.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Declarar el solucionador

El siguiente fragmento de código declara el solucionador SCIP (Solving Constraint Integer Programs), un solucionador de código abierto disponible que permite resolver problemas lineales mixtos (Google OR-Tools posee múltiples solucionadores):

solver = pywraplp.Solver.CreateSolver('SCIP')

Paso 3: Crear las variables del modelo

El siguiente fragmento de código permite crear las variables del modelo. La sintaxis permite declarar la naturaleza de cada una de las variables y el rango de valores permitidos (restricciones de no-negatividad).

    x0 = solver.IntVar(0, solver.infinity(), 'x0')
    x1 = solver.IntVar(0, solver.infinity(), 'x1')
    x2 = solver.IntVar(0, solver.infinity(), 'x2')
    x3 = solver.NumVar(0, solver.infinity(), 'x3')
    x4 = solver.NumVar(0, solver.infinity(), 'x4')

A partir de la declaración de estas variables, el modelo corresponde a un problema de programación lineal mixta.

Paso 4: Definir las restricciones del modelo

El siguiente fragmento de código define las restricciones del modelo:

    # Restricción 0: 0.6x0 + 2x1 + x2 + x3 = 24. (horas metales)
    solver.Add(0.6 * x0 + 2 * x1 + x2 + x3 == 24.0)

    # Restricción 1: x0 + 2x1 + 4x2 + x4 = 60. (horas madera)
    solver.Add(x0 + 2 * x1 + 4 *x2 + x4 == 60.0)

    # Restricción 3: x1 >= 4. (demanda mínima)
    solver.Add(x1 >= 4.0)

Paso 5: Definir la función objetivo del modelo

El siguiente fragmento de código define la función objetivo del modelo:

    # Función objetivo (max): 6x0 + 14x1 + 13x2
    solver.Maximize(6 * x0 + 14 * x1 + 13 * x2)

Paso 6: Invocar el solucionador

El siguiente fragmento de código sirve para invocar el solucionador del modelo:

status = solver.Solve()

Paso 7: Definir las salidas del solucionador

    if status == pywraplp.Solver.OPTIMAL:
        print('Solución:')
        print('Valor objetivo =', solver.Objective().Value())
        print('Número de remolques de plataforma plana producidos por mes =', x0.solution_value())
        print('Número de remolques económicos producidos por mes =', x1.solution_value())
        print('Número de remolques de lujo producidos por mes =', x2.solution_value())
        print('Número de horas ociosas en el trabajo en metal al mes =', x3.solution_value())
        print('Número de horas ociosas en el trabajo en madera al mes =', x4.solution_value())
    else:
      if status == solver.FEASIBLE:
        print('Se encontró una solución potencialmente subóptima.')
      else:
        print('El problema no tiene solución óptima.')

    # Información avanzada del solucionador

    print('\nUso avanzado:')
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())

Es posible que el desarrollo de los siete pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de optimización lineal.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Programación Lineal Mixta.

#Adaptado de: Bradley, Hax, and Magnanti, 'Applied Mathematical Programming', Chapter 2
#Nuevo caso y modelo: Salazar, ingenieriaindustrialonline.com (Programación lineal mixta)

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

def LinearProgrammingExample():
    solver = pywraplp.Solver.CreateSolver('SCIP')

    x0 = solver.IntVar(0, solver.infinity(), 'x0')
    x1 = solver.IntVar(0, solver.infinity(), 'x1')
    x2 = solver.IntVar(0, solver.infinity(), 'x2')
    x3 = solver.NumVar(0, solver.infinity(), 'x3')
    x4 = solver.NumVar(0, solver.infinity(), 'x4')

    print('Número de variables =', solver.NumVariables())

    # Restricción 0: 0.5x0 + 2x1 + x2 + x3 = 24.
    solver.Add(0.6 * x0 + 2 * x1 + x2 + x3 == 24.0)

    # Restricción 1: x0 + 2x1 + 4x2 + x4 = 60.
    solver.Add(x0 + 2 * x1 + 4 *x2 + x4 == 60.0)

    # Restricción 3: x1 >= 4.
    solver.Add(x1 >= 4.0)

    print('Número de restricciones =', solver.NumConstraints())

    # Función objetivo (max): 6x0 + 14x1 + 13x2
    solver.Maximize(6 * x0 + 14 * x1 + 13 * x2)

    # Declarar el solucionador.
    status = solver.Solve()

    # Declarar las salidas del solucionador
    if status == pywraplp.Solver.OPTIMAL:
        print('Solución:')
        print('Valor objetivo =', solver.Objective().Value())
        print('Número de remolques de plataforma plana producidos por mes =', x0.solution_value())
        print('Número de remolques económicos producidos por mes =', x1.solution_value())
        print('Número de remolques de lujo producidos por mes =', x2.solution_value())
        print('Número de horas ociosas en el trabajo en metal al mes =', x3.solution_value())
        print('Número de horas ociosas en el trabajo en madera al mes =', x4.solution_value())
    else:
      if status == solver.FEASIBLE:
        print('Se encontró una solución potencialmente subóptima.')
      else:
        print('El problema no tiene solución óptima.')

    # Información avanzada del solucionador

    print('\nUso avanzado:')
    print('Problema resuelto en %f milisegundos' % solver.wall_time())
    print('Problema resuelto en %d iteraciones' % solver.iterations())

LinearProgrammingExample()

Al ejecutar nuestro desarrollo en Colaboratory, tenemos:

Hemos modificado la naturaleza de las variables con el objetivo de mostrar los resultados a partir de tres escenarios: variables mixtas, enteras y continuas:

El anterior, es un problema lineal que representa un caso sencillo, sin embargo, los resultados obtenidos presentan variaciones menores de acuerdo a la naturaleza de las variables consideradas.

Sin embargo, en modelos robustos, estas variaciones pueden ser considerables y determinantes. Por tal razón, la programación lineal mixta ofrece la posibilidad de modelar variables cuya naturaleza refleje con precisión la realidad que se pretende representar.

Ahora bien, el modelo de optimización lineal mixta y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome los datos de entrada desde un archivo de Excel, o desde un servidor externo.

También, es posible desarrollar una interfaz amigable desde la cual se ingrese la información; o vincular los datos de salida con algún modelo o documento determinado.

La entrada Programación lineal mixta con Google OR-Tools se publicó primero en Ingenieria Industrial Online.

Ahora bien, existen innumerables casos de aplicación práctica en los cuales las soluciones fraccionarias no se ajustan a la realidad y debemos considerar el uso de variables enteras, así entonces, tendremos un modelo de programación lineal entera (PLE). Por ejemplo, pensemos en la producción de lápices, es posible que queramos determinar la producción en términos de unidades de producto, no tanto así de fracciones.

Es preciso mencionar que, cuando un modelo presenta todas sus variables enteras, se denomina puro. En caso contrario, cuando utiliza una combinación de variables enteras y continuas, se denomina mixto, y se abordará mediante programación lineal mixta.

Ciertamente, en la práctica, los solucionadores de modelos de optimización han abordado la naturaleza de las variables brindando relativa facilidad; es decir, podemos cambiar el tipo de variable entre continua y entera de una manera muy sencilla, sin que esto afecte considerablemente el modelo.

El objetivo de este artículo consiste en utilizar las librerías del software Google OR-Tools para abordar problemas de programación lineal entera (optimización lineal entera). 

OR-Tools proporciona dos herramientas principales para resolver este tipo de problemas de optimización:

El problema

Con el propósito de evaluar los resultados obtenidos a través del tratamiento de un problema técnicamente formulado y abordado, utilizaremos un caso descrito en el libro Investigación de Operaciones (9na edición), de Hamdy A. Taha (University of Arkansas, Fayetteville), (Conjunto de problemas 9.1A – Problema 3).

Suponga que tiene 7 botellas de vino llenas, 7 a la mitad y 7 vacías. Le gustaría dividir las 21 botellas entre tres individuos de modo que cada uno reciba exactamente 7. Además, cada individuo debe recibir la misma cantidad de vino. Exprese el problema como restricciones del PLE, y halle una solución. TAHA

Modelamiento del problema

El problema plantea un caso de asignación, en el cual debemos determinar la cantidad de botellas de cada tipo (llenas, medias y vacías), asignadas a cada uno de un conjunto de 3 individuos (1, 2 y 3). Por lo tanto, las variables de decisión se definirán de la siguiente manera:

x_ij = Cantidad de botellas de tipo i asignadas al individuo j

i = {0 = Llena; 1 = Media; 2 = Vacía}

j = {0 = Individuo 1; 1 = individuo 2; 2 = individuo 3}

Donde todos los x_ij son enteros no negativos. (Ya que queremos determinar cantidad de botellas, es decir que las variables de decisión no están formuladas en función del contenido).

Este modelo puede abordar las restricciones de volumen de líquido (contenido igual para todos los individuos), por medio de coeficientes de contenido, o, definiendo que el contenido corresponde a una variable, la cual debe declararse de igual forma. Ya que el contenido que se encuentra en una botella llena, por ejemplo, es el mismo sea asignado a cualquier individuo, la manera más simple de abordarlo es por medio de coeficientes.

En la formulación del modelo de Python lo abordaremos por medio de variables con fines prácticos.

La función objetivo es artificial, dado que el modelo no pretende maximizar o minimizar algún factor. Por lo tanto podemos utilizar cualquier coeficiente, por ejemplo cero.

Zmax = 0x₀₀ + 0x₀₁  +  0x₀₂  + 0x₁₀ + 0x₁₁  +  0x₁₂  + 0x₂₀ + 0x₂₁  +  0x₂₂  

Sujeto a las siguientes restricciones:

x₀₀ + x₀₁  +  x₀₂  = 7

x₁₀ + x₁₁  +  x₁₂  = 7

x₂₀ + x₂₁  +  x₂₂  = 7

Las anteriores restricciones limitan la disponibilidad de botellas de cada tipo. Es decir, por ejemplo, la sumatoria de botellas llenas enviadas a los individuos 1, 2 y 3 deberá ser igual a 7; así mismo para el restante tipo de botellas.

x₀₀ + x₁₀  +  x₂₀  = 7

x₀₁ + x₁₁  +  x₂₁  = 7

x₀₂ + x₁₂  +  x₂₂  = 7

Las anteriores restricciones indican que cada individuo deberá recibir exactamente 7 botellas sin importar el tipo de las mismas. Es decir, por ejemplo, la sumatoria de botellas tipo 0, 1 y 2 enviadas al individuo 0, deberá ser igual a 7; así mismo para los individuos restantes.

Respecto a las restricciones de contenido, que limitarán el modelo para que cada individuo reciba la misma cantidad de vino, podemos realizar una operación previa, en la cual determinemos la cantidad total de vino disponible.

Vino disponible = 1( 7 botellas llenas) + 0,5( 7 botellas medias)

Vino disponible = 10,5 

Así entonces, para que a cada individuo le corresponda la misma cantidad de vino en la distribución de botellas, deberá dividirse el vino disponible entre el total de individuos.

Vino para cada individuo = (10,5 / 3) = 3,5

Así entonces, las restricciones de equidad en la distribución (contenido) serán las siguientes:

x₀₀ + 0,5x₁₀   = 3,5

x₀₁ + 0,5x₁₁  = 3,5

x₀₂ + 0,5x₁₂  = 3,5

Así entonces, tenemos el problema completamente modelado.

Resolución del modelo mediante Google OR-Tools

De acuerdo a lo mencionado en el artículo de introducción a Google OR-Tools, esta herramienta soporta múltiples lenguajes de programación, en esta ocasión, haremos uso del lenguaje de programación Python.

Paso 1: Importar la librería

El siguiente fragmento de código importa las librerías necesarias:

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

Paso 2: Declarar el solucionador

El siguiente fragmento de código declara el solucionador SCIP (Solving Constraint Integer Programs), un solucionador de código abierto disponible (Google OR-Tools posee múltiples solucionadores):

solver = pywraplp.Solver.CreateSolver('SCIP')

Paso 3: Crear la data del modelo

El siguiente fragmento de código crea la data del modelo. En este caso, la matriz de contenido de las botellas distribuidas a los 3 individuos (matriz 3 x 3).

# Crear la data del modelo de asignación
contenido = [
    [  1,   1,   1],
    [0.5, 0.5, 0.5],
    [  0,   0,   0],
]
num_botellas = len(contenido)
num_individuos = len(contenido[0])

Paso 4: Crear las variables del modelo

El siguiente fragmento crea las variables del modelo mediante un bucle (Hace uso número de botellas y el número de individuos), definiendo las variables x [i, j]. Así mismo, se declara el rango de valores que pueden tomar las variables, del mismo modo su naturaleza: variables enteras (solver.IntVar). Esta declaración sustituye las restricciones de no-negatividad (0, solver.infinity()), es decir, mayores a cero.

  x = {}
  for i in range(num_botellas):
      for j in range(num_individuos):
          x[i, j] = solver.IntVar(0, solver.infinity(), '')

Paso 5: Definir las restricciones del modelo

El siguiente fragmento de código define las restricciones del modelo mediante bucles:

# Restricciones de disponibilidad de botellas de cada tipo = 7
# Para cada i (tipo de botella), suma sus posibles variaciones de j (individuos)
# Por ejemplo, siendo i = 0, sumará X00 + X01 + X02, esta sumatoria
# deberá ser igual a 7 (botellas disponibles de cada tipo)
  for i in range(num_botellas):
      solver.Add(solver.Sum([x[i, j] for j in range(num_individuos)]) == 7)
# Restricciones de cantidad de botellas asignadas a cada individuo
# Para cada j (individuo), suma sus posibles variaciones de i (tipos de botella)
# Por ejemplo, siendo j = 0, sumará X00 + X10 + X20, esta sumatoria
# deberá ser igual a 7 (botellas asignadas a un individuo sin importar el tipo)
  for j in range(num_individuos):
      solver.Add(solver.Sum([x[i, j] for i in range(num_botellas)]) == 7)
# Restricciones de equidad en la distribución (utiliza la matriz de contenido)
# Para cada j (individuo), suma los productos de las posibles
# variaciones de i (tipo de botella) por sus coeficientes de contenido
# Por ejemplo, siendo j = 0 y C[i][j] equivalente al contenido
# de una botella tipo i entregado a un individuo tipo j
# sumará (C00 * X00) + (C10 * X10) + (C20 * X20), los valores de C[i][j]
# los tomará de la matriz de contenido. Esta sumatoria
# deberá ser igual a 3,5 (distribución equitativa por individuo)
  for j in range(num_individuos):
      solver.Add(solver.Sum([contenido[i][j] * x[i, j] for i in range(num_botellas)]) == 3.5)

Paso 6: Definir la función objetivo del modelo

El siguiente fragmento de código define la función objetivo del modelo. Consideremos que no es importante el criterio de la función, tampoco existe un costo asociado a las variables de decisión. Sin embargo, formularemos una función objetivo basada en bucles (utilizando la matriz de contenido), la cual quizá puede ser de utilidad en modelamientos futuros. Los coeficientes de las variables de decisión se basarán en la matriz de contenido (contenido[i][j]).

# Función objetivo
  objective_terms = []
  for i in range(num_botellas):
      for j in range(num_individuos):
          objective_terms.append(contenido[i][j] * x[i, j])
  solver.Maximize(solver.Sum(objective_terms))

Paso 7: Invocar el solucionador

El siguiente fragmento de código sirve para invocar el solucionador del modelo:

status = solver.Solve()

Paso 8: Definir las salidas del solucionador

# Configura los parámetros de impresión, las salidas del modelo
botellas_ind0 = 0
botellas_ind1 = 0
botellas_ind2 = 0  
if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
      print('Puntaje total = ', solver.Objective().Value(), '\n')
      for i in range(num_botellas):
          for j in range(num_individuos):
              # Test if x[i,j] is 1 (con tolerancia de punto flotante)
              if x[i, j].solution_value() > 0.5:
                print('Botellas del tipo %d asignadas al individuo %d.  Cantidad = %d' %
                          (i, j, x[i, j].solution_value()))
      for i in range(num_botellas):
          botellas_ind0 = x[i, 0].solution_value() + botellas_ind0
      for i in range(num_botellas):
          botellas_ind1 = x[i, 1].solution_value() + botellas_ind1
      for i in range(num_botellas):
          botellas_ind2 = x[i, 2].solution_value() + botellas_ind2
  print('Número de botellas asignadas al individuo 0:', botellas_ind0)
  print('Número de botellas asignadas al individuo 1:', botellas_ind1)
  print('Número de botellas asignadas al individuo 2:', botellas_ind2)

En este caso, configuramos las salidas del solucionador. Nos deberá indicar la cantidad de botellas de cada tipo que deberán ser distribuidas a cada individuo. El valor de la función objetivo (contenido total), nos servirá para verificar la solución (10,5).

Como información adicional, hemos configurado algunas impresiones (arbitrarias) para que nos detalle la cantidad de botellas que le deberán ser asignadas a cada individuo.

Es posible que el desarrollo de los ocho pasos anteriores demande algún grado de complejidad subyacente del uso de un lenguaje de programación; sin embargo, es preciso mencionar que, el modelo anterior queda perfectamente configurado, y puede replicarse con modificaciones menores en múltiples problemas de optimización lineal.

¿Cómo ejecutar el modelo?

Alternativa 1, ejecución en nuestro equipo:

Lo primero que debemos considerar, en el caso de que queramos ejecutar este código en nuestro equipo, es que es preciso contar con la instalación de Python en nuestro equipo de cómputo, así mismo debemos contar con la última versión del comando pip y por supuesto, el software OR-Tools. Una guía detallada de la instalación de estos requerimientos la podrás encontrar en el siguiente enlace:

Instalación de OR-Tools para Python

Ahora, lo recomendable es trabajar con algún editor de código práctico (IDE), por ejemplo: Sublime Text, o Spyder (Una herramienta más completa y por ende más robusta y pesada).

Alternativa 2, ejecución en un entorno virtual (Recomendado):

Podemos utilizar del mismo modo, un entorno virtual. En este caso recomendamos el uso de Colaboratory de Google, un entorno que cuenta con todas las herramientas necesarias para nuestros desarrollos. No tendremos que instalar nada en nuestro equipo, y aprovecharemos la potencia de las máquinas de Google.

El código completo de nuestro desarrollo lo presentamos a continuación. También puedes ver el cuaderno de este módulo en nuestro Colaboratory: Programación Lineal Entera.

# Caso: Investigación de Operaciones (9na edición), de Hamdy A. Taha 
# (University of Arkansas, Fayetteville), (Conjunto de problemas 9.1A - Problema 3)
# Modelo: MSc. Ing. Bryan Salazar López

# Importar la librería de Google OR-Tools
from ortools.linear_solver import pywraplp

# Declarar el solucionador que abordará el modelo
solver = pywraplp.Solver.CreateSolver('SCIP')

# Data del modelo

contenido = [ 
    [  1,   1,   1], 
    [0.5, 0.5, 0.5],
    [  0,   0,   0],      
] 
num_botellas = len(contenido)
num_individuos = len(contenido[0])


def main():

# Variables del modelo
  x = {}
  for i in range(num_botellas):
      for j in range(num_individuos):
          x[i, j] = solver.IntVar(0, solver.infinity(), '')

  # Las sumatoria de botellas de cada tipo es igual a 7
  # Cada curso podrá tener un máximo de n estudiantes
  for i in range(num_botellas):
      solver.Add(solver.Sum([x[i, j] for j in range(num_individuos)]) == 7)
  for j in range(num_individuos):
      solver.Add(solver.Sum([x[i, j] for i in range(num_botellas)]) == 7)
  for j in range(num_individuos):
      solver.Add(solver.Sum([contenido[i][j] * x[i, j] for i in range(num_botellas)]) == 3.5)



  # Función objetivo con criterio de optimización: minimizar
  objective_terms = []
  for i in range(num_botellas):
      for j in range(num_individuos):
          objective_terms.append(contenido[i][j] * x[i, j])
  solver.Maximize(solver.Sum(objective_terms))

  # Invoca el solucionador
  status = solver.Solve()

  # Configura los parámetros de impresión, las salidas del modelo
  botellas_ind0 = 0
  botellas_ind1 = 0
  botellas_ind2 = 0
  if status == pywraplp.Solver.OPTIMAL or status == pywraplp.Solver.FEASIBLE:
      print('Contenido total = ', solver.Objective().Value(), '\n')
      for i in range(num_botellas):
          for j in range(num_individuos):
              # Test if x[i,j] is 1 (con tolerancia de punto flotante)
              if x[i, j].solution_value() > 0.5:
                print('Botellas del tipo %d asignadas al individuo %d.  Cantidad = %d' %
                          (i, j, x[i, j].solution_value()))
      for i in range(num_botellas):
          botellas_ind0 = x[i, 0].solution_value() + botellas_ind0
      for i in range(num_botellas):
          botellas_ind1 = x[i, 1].solution_value() + botellas_ind1
      for i in range(num_botellas):
          botellas_ind2 = x[i, 2].solution_value() + botellas_ind2
  print('Número de botellas asignadas al individuo 0:', botellas_ind0)
  print('Número de botellas asignadas al individuo 1:', botellas_ind1)
  print('Número de botellas asignadas al individuo 2:', botellas_ind2)



if __name__ == '__main__':
  main()

Al ejecutar nuestro desarrollo en Colaboratory, tenemos:

De esta manera se ha hallado una solución óptima al modelo formulado. Esta misma respuesta se encuentra consignada en el libro Investigación de Operaciones de TAHA:

Ahora bien, el modelo de optimización lineal y el script del solucionador quedaron desarrollados en un lenguaje de programación estándar y ampliamente utilizado. Desde luego, las posibilidades de integrar datos de entrada y procesar los datos de salidas son interesantes. Por ejemplo, es posible desarrollar un script mediante el cual el código ya desarrollado tome los datos de entrada desde un archivo de Excel, o desde un servidor externo.

También, es posible desarrollar una interfaz amigable desde la cual se ingrese la información; o vincular los datos de salida con algún modelo o documento determinado.

En próximos artículos abordaremos algunos modelos que incorporen la combinación de tipos de variables (continuas y enteras): programación lineal mixta.

La entrada Programación lineal entera con Google OR-Tools se publicó primero en Ingenieria Industrial Online.