Programação Linear

Este documento tem como objetivo apresentar conceitos de programação linear e como implementar tais problemas de otimização no R.

INTRODUÇÃO

Um problema geral de Programação Linear é utilizado para otimizar (maximizar ou minimizar) uma função linear de variáveis, chamada de função objetivo, sujeita a uma série de equações (ou inequações) lineares, chamadas restrições. Assim, temos que Programação linear é um caso de programação matemática onde a função objetivo e as restrições são todas lineares.

Abaixo, um exemplo de problema de programação linear:

\[ \begin{aligned} & \text{MAX} & & z = c_{1}x_{1}+c_{2}x_{2}+...+c_{n}x_{n} \\ & \text{s.a.} & & a_{11}x_{1}+a_{12}x_{2}+...+a_{1n}x_{n}\leq b_{1} \\ &&& a_{21}x_{1}+a_{22}x_{2}+...+a_{2n}x_{n}\leq b_{2} \\ &&& \ldots \ldots \ldots \ldots \ldots \ldots \ldots \ldots \ldots \\ &&& a_{m1}x_{1}+a_{m2}x_{2}+...+a_{mn}x_{n}\leq b_{m} \\ &&& x_{j} \geq 0 \end{aligned} \] O modelo tem os seguintes elementos:

• Uma função objetivo com \(n\) variáveis de escolha que são afetadas por seus coeficientes, \(c_{j}\), para \(j=1,...,n\).
• Um conjunto de \(m\) restrições em que uma combinação linear das variáveis de escolha afetadas pelos coeficientes \(a_{ij}\) devem ser menor ou igual aos valores do lado direito das equações, \(b_{i}\) para \(i=1,...m\)
• Limites das variáveis de escolha. Neste caso, todas precisam assumir valores não negativos (\(x_{j} \geq 0\))

As restrições de um problema de programação linear definem a região viável, que é o conjunto de valores que satisfazem todas as restrições. Tais restrições também podem ter sinal de \(\geq\) ou \(=\).

Outra maneira usual de expressar o problema de programação linear é no formato matricial, como segue:

\[ \begin{aligned} & \text{MAX} & & z = c^{\prime}x \\ & \text{s.a.} & & \boldsymbol{A}x \leq \boldsymbol{b} \\ &&& x \geq 0 \end{aligned} \]

\[ \begin{aligned} & \text{MIN} & & z = c^{\prime}x \\ & \text{s.a.} & & \boldsymbol{A}x \geq \boldsymbol{b} \\ &&& x \geq 0 \end{aligned} \] onde letras maiúsculas em negrito são matrizes e letras minúsculas em negrito são vetores.

TERMINOLOGIA PARA SOLUÇÕES DE MODELOS

Você deve estar acostumado a ver o termo solução com o significado de resposta final para um problema, porém, a convenção em programação linear (e suas extensões) é bem diferente. Aqui, qualquer especificação de valores para as variáveis de decisão (\(x_{1},x_{2},...,x_{n}\)) é chamda solução, idependentemente de ela ser desejável ou até mesmo ser uma opão admissível. Diferentes tipos de soluções são então identificados usando-se um adjetivo apropriado.

Uma solução viável é aquela para a qual todas as restrições são satisfeitas. Já uma solução inviável é aquela para a qual pelo menos uma das restrições é violada. Dado que existem soluções viáveis, o objetivo da programação linear é encontrar a melhor solução viável conforme medida pelo valor da função objetivo no modelo.

O valor mais favorável é o maior valor se a função objetivo tiver de ser maximizada, ao passo que será o menor valor caso ela deva ser minimizada. A maior parte dos problemas terá apenas uma solução ótima. Entretanto, é possível ter mais de uma. Outra possibilidade é que um problema não tenha nenhuma solução ótima. Isso acontece apenas se:

• se não existir nenhuma solução viável;
• as restrições não impedirem que se aumente indefinidamente o valor da função objetivo na direção favorável (positiva ou negativa). Este caso é conhecido como **função objetivo ilimitada.

EXEMPLO DE PROBLEMA DE PROGRAMAÇÃO LINEAR

Uma pequena empresa vende dois produtos, Produto 1 e Produto 2. Cada tonelada do Produto 1 consome 30 horas de trabalho e cada tonelada do Produto 2 consome 20 horas de trabalho. A empresa tem no máximo 2700 horas de trabalho para o período considerado.

Além disso, cada tonelada dos Produtos 1 e 2 consome 5 e 10 horas de máquina para processar a matéria prima, respectivamente. Sabe-se que a empresa tem 850 horas disponíveis para processamento da matéria prima.

Cada tonelada vendida do Produto 1 gera 20 mil reais de lucro enquanto para o Produto 2 o valor é de 60 mil reais. Por razões técnicas a empresa deve produzir no mínimo um total de 95 toneladas. Nosso objetivo é saber quantas toneladas dos dois produtos devem ser produzidas para maximar o lucro total da empresa.

O problema exposto pode ser escrito da seguinte forma:

\[ \begin{aligned} & \text{MAX} & & z = 20P_{1}+60P_{2} \\ & \text{s.a.} & & 30P_{1}+20P_{2}\leq 2700 \\ &&& 5P_{1}+10P_{2}\leq 850 \\ &&& P_{1}+P_{2}\geq 95 \\ &&& P_{1} \geq 0 \\ &&& P_{2} \geq 0 \end{aligned} \]

RESOLVENDO PROBLEMAS DE PROGRAMAÇÃO LINEAR

O procedimento mais utilizado para resolver um problema de programação linear é usar o algoritmo simplex desenvolvido por Dantzig (1951). Outra alternativa para problemas com até duas variáveis é o método gráfico.

• MÉTODO GRÁFICO

Problemas de programação linear com até duas variáveis de decisão podem ser representados e resolvidos graficamente. Embora limitada, a representação gráfica permite evidenciar propriedades e as diversas situações que podem ser encontradas ao se resolver problemas com um número maior de variáveis. Para efeito de exposição, considere o seguinte problema de programação linear:

\[ \begin{aligned} & \text{MAX} & & z = x_{1}+2x_{2} \\ & \text{s.a.} & & x_{1}+x_{2}\leq 8 \\ &&& -x_{1}+2x_{2}\leq 4 \\ &&& 2x_{1}-x_{2}\leq 12 \\ &&& x_{1} \geq 0 \\ &&& x_{2} \geq 0 \end{aligned} \] Considere o plano \(x_1 \times x_2\), com os eixos das abcissas e das ordenadas representando possíveis valores para as variáveis de decisão \(x_{1}\) e \(x_{2}\). Cada uma das restrições descreve uma região do plano. Para obter a região associada à restrição \(x_{1}+x_{2}\leq 8\), descreve-se inicialmente a reta \(x_{1}+x_{2}= 8\), que passa pelos pontos \((0,8)\) e \((8,0)\). A reta \(x_{1}+x_{2}= 8\) divide o plano em semiplanos, \(x_{1}+x_{2}\leq 8\) e \(x_{1}+x_{2}\ge 8\).

Repete-se o procedimento para todas as restrições presentes no modelo. A interseção das regiões descritas pelos semiplanos representa a região viável do problema ilustrada na figura abaixo.

A região viável possui infinitos pontos e, em princípio, qualquer um deles pode ser uma solução ótima do problema. Para determinar qual deles produz o maior valor para \(z\), usa-se o fato de que \(x_{1}+2x_{2}=z\) descreve uma família de retas paralelas de inclinação \(-0.5\) parametrizada pelo valor de \(z\). Diferentes valores de \(z\) levam a diferentes pontos de cruzamento com os eixos \(x_1\) e \(x_2\). Retas correspondentes a valores selecionados de \(z\) encontram-se representadas na figura acima. Para determinar o sentido de crescimento de \(z\), utiliza-se o conceito de gradiente de uma função num ponto. O vetor gradiente de qualquer função diferenciável \(z=f(x)\) de \(n\) variáveis num ponto \(x=(x_1,x_2,...,x_n)\), denotado por \(\nabla f(x)\), é o vetor formado pelas primeiras derivadas parciais da função no ponto considerado:

\[ \nabla f(x) = \left( \frac { \partial f\left( x \right) }{ \partial { x }_{ 1 } } ,\frac { \partial f\left( x \right) }{ \partial { x }_{ 2 } } ,...,\frac { \partial f\left( x \right) }{ \partial { x }_{ n } } \right) \] O vetor gradiente indica o sentido de maior crescimento da função no entorno do ponto considerado. Observa-se que o vetor gradiente de uma função linear,

\[ z=c_1x_1+c_2x_2+...+c_nx_n \] é constante e dado por

\[ c=(c_1,c_2,...,c_n) \] No caso do exemplo ilustrativo, \(c=(1,2)\). O sentido do gradiente está indicado na figura anterior. O vetor gradiente é ortogonal a qualquer reta que descreva um valor para a função objetivo.

Resumindo, a maximização do valor da função-objetivo no problema descrito pode ser conduzida da seguinte forma:

• percorrer a região viável do problema no sentido do gradiente (aumentando continuamente o valor da função objetivo) até que a fronteira da região seja eventualmente atingida;
• o valor máximo da função-objetivo na região viável é dado pelo valor da reta que toca a fronteira, no caso \(z^{\ast}=12\). Qualquer ponto que pertenca à reta de valor \(z^{\ast}=12\) que também percente à fronteira é uma solução ótima do problema. No caso do exemplo, existe apenas uma solução ótima, \(x^{\ast}=(4,4)\).

Se o objetivo do problema fosse, ao invés de maximizar, minimizar o valor de \(z\), adotar-se-ia a direção contrária à do gradiente, ou seja, a de maior decrescimento da função. O valor mínimo da função-objetivo seria \(z^{\ast}=0\), obtido no ponto \(x^{\ast}=(0,0)\).

• MÉTODO SIMPLEX

O algoritmo simplex se aproveita do fato que o ótimo de um problema de programação linear pode ser encontrado explorando suas soluções básicas. As soluções básicas correspondem aos vértices da região viável do problema. A estratégia do algoritmo simplex será:

• Encontrar a solução básica inicial
• Explorar as soluções básicas movendo na direção que maximiza ou minimiza a função objetivo
• Parar quando uma solução ótima é encontrada

Softwares que resolvem problemas de programação linear quase sempre fazem uso do algoritmo simplex ou sua versão revisada que é uma variante que está implementada para ser mais eficiente. Existem outros algoritmos para problemas particulares de programação linear tal como: transporte de uma origem para um destino ou problema de fluxo máximo.

RESOLVENDO PROBLEMAS DE PROGRAMAÇÃO LINEAR NO R

Existem vários solvers disponíveis para resolver problemas de programação linear. Uma lista deles pode ser encontrada neste link. Alguns deles também são implementados no R, como segue:

• lp_solve que é disponibilizado no R por meio dos pacotes lpSolve e lpSolveAPI;
• GLPK que no R pode ser usado via pacote Rglpk;
• SYMPHONY que está disponível no R via pacote Rsymphony

Alguns destes pacotes têm funções que permitem a leitura de arquivos contendo problemas de programação linear, programação linear inteira e programação linear inteira mista escritos no formato CPLEX, por exemplo.

• Resolvendo problemas de programaçaõ linear usando o pacote lpSolve:

1. Considere o exemplo apresentado anteriormente, abaixo temos a solução do problema de programação linear no R.

##########################
####     PACOTES     #####
##########################
# Instalar pacotes necessários para o restante do documento
#install.packages(c("lpSolve","lpSolveAPI", "ggplot2","plotly"))
# Carregar pacotes necessários para o restante do documento
suppressMessages(require(lpSolve))
suppressMessages(require(lpSolveAPI))
suppressMessages(require(ggplot2))
suppressMessages(require(plotly))
##########################
####     PROBMELA    #####
##########################
# coeficientes de P1 e P2 na função objetivo 
func.objetivo <- c(20 , 60)
# coeficientes de P1 e P2 nas restrições. Sempre em matriz como mostrado no texto acima
coeficientes.restricoes <- matrix (c(30, 20, 5, 10, 1, 1), ncol = 2 , byrow = TRUE)
# sinal das restrições. Deve obedecer a ordem da matriz de coeficientes
direcao.restricoes <- c("<=","<=",">=")
# limite das restrições. Deve obedecer a ordem da matriz de coeficientes
limites.restricoes <- c(2700, 850, 95)
##########################
####     SOLUÇÃO     #####
##########################
# Basicamente, usamos a função lp do pacote lpSolve com os seguintes parâmetros:
# direction: que recebe max ou min dependendo se o problema é de maximização ou minização, respectivamente
# objective.in: que recebe o nome do vetor com parâmetros da função objetivo
# const.mat: que recebe o nome da matriz com coeficientes das restrições
# const.rhs: que recebe o nome do vetor com os limites das restrições
# mais opções da função podem ser obtidas por meio do help(lp)
solucao.problema <- lpSolve::lp(direction = "max",             
                               objective.in = func.objetivo,  
                               const.mat = coeficientes.restricoes,
                               const.dir = direcao.restricoes,
                               const.rhs = limites.restricoes)
##########################
####    RESULTADO    #####
##########################
# valor da função objetivo na solução
solucao.problema$objval

[1] 4900

# Valores para as variáveis de escolha que geram máximo ou mínimo dependendo do problema
solucao.problema$solution

[1] 20 75

2. Considere o seguinte problema de minimização:

\[ \begin{aligned} & \text{MIN} & & z = -3x_{1}-4x_{2}-3x_{3} \\ & \text{s.a.} & & 6x_{1}+2x_{2}+4x_{3}\leq 150 \\ &&& x_{1}+x_{2}+6x_{3}\geq 0 \\ &&& 4x_{1}+5x_{2}+4x_{3}= 40 \\ &&& x_{1} \geq 0 \\ &&& x_{2} \geq 0 \\ &&& x_{3} \geq 0 \\ \end{aligned} \]

##########################
####     PROBMELA    #####
##########################
# coeficientes de X1, X2 e X3 na função objetivo 
func.objetivo.prob2 <- c(-3 , -4, -3)
# coeficientes de X1, X2 e X3 nas restrições. 
coeficientes.restricoes.prob2 <- matrix (c(6, 2, 4, 1, 1, 6, 4, 5, 4), ncol = 3 , byrow = TRUE)
# sinal das restrições. Deve obedecer a ordem da matriz de coeficientes
direcao.restricoes.prob2 <- c("<=",">=","=")
# limite das restrições. Deve obedecer a ordem da matriz de coeficientes
limites.restricoes.prob2 <- c(150, 0, 40)
##########################
####     SOLUÇÃO     #####
##########################
solucao.problema2 <- lpSolve::lp(direction = "min",             
                               objective.in = func.objetivo.prob2,  
                               const.mat = coeficientes.restricoes.prob2,
                               const.dir = direcao.restricoes.prob2,
                               const.rhs = limites.restricoes.prob2)
##########################
####    RESULTADO    #####
##########################
# valor da função objetivo na solução
solucao.problema2$objval

[1] -32

# Valores para as variáveis de escolha que geram máximo ou mínimo dependendo do problema
solucao.problema2$solution

[1] 0 8 0

3. Uma Companhia aérea está acrescentando mais vôos de/para seu aeroporto central e, para tanto, precisa contratar mais agentes para o atendimento ao público. Entretanto, não está claro quantas pessoas eles devem contratar. A gerência reconhece a necessidade de controle de custos, embora mantendo, ao mesmo tempo, um nível de serviços satisfatório a seus clientes.

Para isso, uma equipe está estudando como programar as escalas desses agentes para fornecer bons serviços aos clientes com o menor custo possível em termos de pessoal.

Tomando como base a nova escala de vôos, foi realizada uma análise do número mínimo de agentes de atendimento ao cliente que precisavam estar de serviço em diferentes horas do dia para fornecer um nível de serviço satisfatório. A coluna mais à direita da tabela abaixo mostra o número de agentes necessários para os períodos dados na primeira coluna. Os demais campos dessa tabela refletem uma das cláusulas no contrato atual da empresa com o sindicato que representa os agentes de atendimento ao cliente. Essa cláusula diz que cada agente trabalha cinco dias por semana em turnos de oito horas e os turnos autorizados são:

• Turno 1: 6h-14h
• Turno 2: 8h-16h
• Turno 3: 12h-20h
• Turno 4: 16h-00h
• Turno 5: 22h-6h

Período do Dia	Turno					Número mínimo de agentes necessários
	1	2	3	4	5
6h-8h	x					48
8h-10h	x	x				79
10h-12h	x	x				65
12h-14h	x	x	x			87
14h-16h		x	x			64
16h-18h			x	x		73
18h-20h			x	x		82
20h-22h				x		43
22h-00h				x	x	52
00h-06h					x	15
Custo diário por agente	170	160	175	180	195

As marcas de verificação (x) no corpo da tabela indicam os horários cobertos pelos respectivos turnos. Pelo fato de alguns turnos serem menos desejados do que outros, os salários especificados no contrato diferem conforme o turno. Para cad turno, o pagamento diário (incluindo benefícios) para cada agente é mostrado na ultima linha da tabela. O problema é determinar quantos agentes devem ser alocados para os respectivos turnos diários a fim de minimizar o custo total com pessoal (agentes) tomando como base a última linha da tabela e, ao mesmo tempo, atendendo (ou ultrapassando) as exigências de nível de serviço dadas na coluna mais à direita.

Pelo fato de a função objetivo minimizar o custo total dos aentes atribuídos aos cinco turnos, os coeficientes na funç]ao objetivo são dados pela última linha da tabela. Portanto, o problema de programação linear completo é:

\[ \begin{aligned} & \text{MIN} & & z = 170x_{1}+160x_{2}+175x_{3}+180x_{4}+195x_{5} \\ & \text{s.a.} & & x_{1}\geq 48 && \text{(6h-8h)} \\ &&& x_{1}+x_{2}\geq 79 && \text{(8h-10h)} \\ &&& x_{1}+x_{2}\geq 65 && \text{(10h-12h)} \\ &&& x_{1}+x_{2}+x_{3} \geq 87 && \text{(12h-14h)} \\ &&& x_{2}+x_{3} \geq 64 && \text{(14h-16h)} \\ &&& x_{3}+x_{4} \geq 73 && \text{(16h-18h)} \\ &&& x_{3}+x_{4} \geq 82 && \text{(18h-20h)} \\ &&& x_{4} \geq 43 && \text{(20h-22h)} \\ &&& x_{4}+x_{5} \geq 52 && \text{(22h-00h)} \\ &&& x_{5} \geq 15 && \text{(00h-6h)} \\ &&& x_{j} \geq 0 && \text{para j=1,2,3,4,5} \\ \end{aligned} \] Com um olhar aguçado, você provavelmente deve ter percebido que a terceira restrição, \(x_{1}+x_{2}\geq 65\), na verdade não é necessária, pois a segunda restrição \(x_{1}+x_{2}\geq 79\), garante que \(x_{1}+x_{2}\) será maior que 65. Portanto, \(x_{1}+x_{2}\geq 65\) é uma restrição redundante que pode ser eliminada.

Da mesma forma, a sexta restrição \(x_{3}+x_{4} \geq 7\), também é redundante porque a sétima restrição é \(x_{3}+x_{4} \geq 82\). Na realidade, três das restrições de não-negatividade também são redundantes em razão da primeira, oitava e décima restrições funcionais: \(x_{1}\geq 48\), \(x_{4} \geq 43\) e \(x_{5} \geq 15\). Entretanto, não se ganha nenhuma vantagem em termos computacionais eliminando-se essas três restrições de não-negatividade.

##########################
####     PROBMELA    #####
##########################
# coeficientes de X1, X2 e X3 na função objetivo 
func.objetivo.prob3 <- c(170, 160, 175, 180, 195)
# coeficientes de X1, X2 e X3 nas restrições. 
coeficientes.restricoes.prob3 <- matrix (c(1, 0, 0, 0, 0, 
                                          1, 1, 0, 0, 0,
                                          1, 1, 1, 0, 0,
                                          0, 1, 1, 0, 0,
                                          0, 0, 1, 1, 0,
                                          0, 0, 0, 1, 0,
                                          0, 0, 0, 1, 1,
                                          0, 0, 0, 0, 1), 
                                        ncol = 5 , byrow = TRUE)
# sinal das restrições. Deve obedecer a ordem da matriz de coeficientes
direcao.restricoes.prob3 <- c(">=",">=",">=",">=",">=",">=",">=",">=")
# limite das restrições. Deve obedecer a ordem da matriz de coeficientes
limites.restricoes.prob3 <- c(48, 79, 87, 64, 82, 43, 52, 15)
##########################
####     SOLUÇÃO     #####
##########################
solucao.problema3 <- lpSolve::lp(direction = "min",             
                               objective.in = func.objetivo.prob3,  
                               const.mat = coeficientes.restricoes.prob3,
                               const.dir = direcao.restricoes.prob3,
                               const.rhs = limites.restricoes.prob3)
##########################
####    RESULTADO    #####
##########################
# valor da função objetivo na solução
solucao.problema3$objval

[1] 30610

# Valores para as variáveis de escolha que geram máximo ou mínimo dependendo do problema
solucao.problema3$solution

[1] 48 31 39 43 15

A solução ótima para esse modelo é \((x_{1},x_{2},x_{3},x_{4},x_{5})=(48,31,39,43,15)\). Isso faz com que \(Z=30.610\), isto é, um custo diário total com pessoal de U$30.610.

O número de agentes alocados para cada turno precisa ser um inteiro. Rigorosamente falando, o modelo deveria ter uma restrição adicional para cada variável de decisão especificando que a variável deve ter um valor inteiro. Acrescentar essas restrições transformaria o modelo de programação linear em um modelo de programação inteira.

• Resolvendo problemas de programação linear usando o pacote lpSolveAPI:

Considere que temos o seguinte problema de programação linear:

\[ \begin{aligned} & \text{MIN} & & z = x_{1}+3x_{2}+6.24x_{3}+0.1x_{4} \\ & \text{s.a.} & & 78.26x_{2}+2.9x_{4}\geq 92.3 \\ &&& 0.24x_{1}+11.31x_{3}\leq 14.8 \\ &&& 12.68x_{1}+0.08x_{3}+0.9x_{4} \geq 4 \end{aligned} \] onde \(x_1\) é uma variável com valor mínimo de \(28.6\), \(x_2\) é uma variável não-negativa e inteira, \(x_3\) é uma variável binária e \(x_4\) é uma variável limitada ao intervalo \([18,48.98]\). Assim, por meio do pacote lpsolveAPI, temos a seguinte solução:

##########################
####     PROBMELA    #####
##########################
# Primeiro, criamos o problema com 3 restrições e 4 variáveis. Observe
# que abaixo sempre usaremos "lprec" para dizer que estamos adicionando
# definições ao problema
lprec <- lpSolveAPI::make.lp(3,4)
# Depois, definimos os valores da primeira coluna da matriz de restrições:
# - 1: indica a primeira coluna
# - c(0, 0.24, 12.68): os coeficientes de x1 nas restrições
lpSolveAPI::set.column(lprec, 1, c(0, 0.24, 12.68))
# Fazemos o mesmo para as demais variáveis (colunas). Aqui, usamos
# a opção indices que vai dizer em qual posição da coluna há valor, 
# pois em alguns casos podemos não ter nas restrições valores para
# outras variáveis
lpSolveAPI::set.column(lprec, 2, 78.26, indices = 1)
lpSolveAPI::set.column(lprec, 3, c(11.31, 0.08), indices = 2:3)
lpSolveAPI::set.column(lprec, 4, c(2.9, 0.9), indices = c(1,3))
# Agora, definimos a função objetivo
lpSolveAPI::set.objfn(lprec, c(1,3, 6.24, 0.1))
# Tipos de restrições
lpSolveAPI::set.constr.type(lprec, c(">=", "<=", ">="))
# Limite das restrições
lpSolveAPI::set.rhs(lprec, c(92.3, 14.8, 4))
# Por default, todas as variáveis são criadas como um valor real no 
# intervalo [0, infinito]. Assim, devemos mudar isso caso o problema
# demande. No nosso exemplo, temos:
# - x2: inteiro
# - x3: binário
lpSolveAPI::set.type(lprec, 2, "integer")
lpSolveAPI::set.type(lprec, 3, "binary")
# Definir o intervalo para as variáveis x1 e x4
# - x1: valor mínimo de 28.6 (primeira coluna)
# - x4: valor mínimo de 18 e máximo de 48.98 (quarta coluna)
lpSolveAPI::set.bounds(lprec, lower = c(28.6, 18), columns = c(1, 4))
lpSolveAPI::set.bounds(lprec, upper = 48.98, columns = 4)
# Finalmente, podemos renomear as variáveis do problema
RowNames <- c("ROWONE","ROWTWO", "ROWTHREE")
ColNames <- c("COLONE","COLTWO", "COLTHREE", "COLTFOUR")
dimnames(lprec) <- list(RowNames, ColNames)
# Definir se é um problema de maximização ou minimização
# Se maximização sense = c("max"). Use help(lp.control.options)
# para visualizar todas as opções que podem ser alteradas em
# um problema de otimização usando este pacote.
minimizar <- lpSolveAPI::lp.control(lprec, sense = c("min"))
# Visualizar o problema definido em um formato que seja fácil
# conferir se está tudo em conformidade com o problema a ser 
# resolvido
lprec

Model name: 
            COLONE    COLTWO  COLTHREE  COLTFOUR          
Minimize         1         3      6.24       0.1          
ROWONE           0     78.26         0       2.9  >=  92.3
ROWTWO        0.24         0     11.31         0  <=  14.8
ROWTHREE     12.68         0      0.08       0.9  >=     4
Kind           Std       Std       Std       Std          
Type          Real       Int       Int      Real          
Upper          Inf       Inf         1     48.98          
Lower         28.6         0         0        18          

Agora, podemos solucionar o problema como segue:

##########################
####     SOLUÇÃO     #####
##########################
# Solucionar o problema definido anteriormente usando a função
# solve.lpExtPtr do pacote lpSolveAPI. Aqui, o solver apenas
# informa o status da solução, como segue:
# 0:     "optimal solution found"
# 1:     "the model is sub-optimal"
# 2:     "the model is infeasible"
# 3:     "the model is unbounded"
# 4:     "the model is degenerate"
# 5:     "numerical failure encountered"
# 6:     "process aborted"
# 7:     "timeout"
# 9:     "the model was solved by presolve"
# 10:    "the branch and bound routine failed"
# 11:    "the branch and bound was stopped because of a break-at-first or break-at-value"
# 12:    "a feasible branch and bound solution was found"
# 13:    "no feasible branch and bound solution was found"
solucao.problema4 <- lpSolveAPI::solve.lpExtPtr(lprec)
##########################
####    RESULTADO    #####
##########################
# valor da função objetivo na solução
lpSolveAPI::get.objective(lprec)

[1] 31.78276

# Valores para as variáveis de escolha que geram máximo ou mínimo dependendo do problema
lpSolveAPI::get.variables(lprec)

[1] 28.60000  0.00000  0.00000 31.82759

REFERÊNCIAS

Chiang, Alpha C., and Kevin Wainwright. 2006. Matemática Para Economistas. Elsevier.

Dantzig, George B. 1951. “Maximization of a Linear Function of Variables Subject to Linear Inequalities.” New York.

Hillier, Frederick S, and Gerald J Lieberman. 2013. Introdução à Pesquisa Pesquisa Operacional. McGraw Hill Brasil.

Soetaert, Karline, and Peter MJ Herman. 2008. A Practical Guide to Ecological Modelling Using R as a Simulation Platform. Springer Science & Business Media.