Programação Não-Linear

Este documento tem como objetivo apresentar conceitos de programação não-linear e como implementar tais problemas de otimização no R. Desta forma, vamos apresentar como identificar um problema de programação não-linear e seus diversos tipos.

INTRODUÇÃO

Os modelos de Programação Linear são utilizados para otimizar (maximizar ou minimzar) uma função objetivo linear bem como restrições lineares. Porém, a necessidade de linearidade é a maior das restrições impostas sobre um modelo de Programação.

De fato, muitos economistas descobriram que algum grau de não-linearidade é a regra e não a exceção em problemas de planejamento econômico. Portanto, muitas vezes é necessário lidar diretamente com problemas de programação não-linear.

Em geral, o problema de programação não-linear é encontrar \(x =(x_1,x_2,...,x_n)\) de modo a:

\[ \begin{aligned} & \text{MAX (MIN)} & & F(\boldsymbol{x}) \\ & \text{s.a.} & & G_{i}(\boldsymbol{x}) \leq b_{i} && \text{para i=1,2,...,m} \\ &&& \boldsymbol{x} \geq \boldsymbol{0} \end{aligned} \] em que \(F(\boldsymbol{x})\) e os \(G_{i}(\boldsymbol{x})\) são funções dadas das \(n\) variáveis de escolha.

Há muitos tipos de problemas de programação não-linear, dependendo das características das funções \(F(\boldsymbol{x})\) e os \(G_{i}(\boldsymbol{x})\). Diferentes algoritmos são usados para os diferentes tipos. Para certos tipos em que as funções têm formas simples, os problemas podem ser resolvidos de forma relativamente eficiente.

EXEMPLO DE PROBLEMA DE PROGRAMAÇÃO NÃO-LINEAR

Hoje em dia é prática comum entre os administradores profissionais de grandes carteiras de ações usarem modelos computacionais baseados parcialmente em programação não-linear para orientá-los. Pelo fato de os investidores estarem preocupados com o retorno esperado (ganho) e o risco associado a seus investimentos, a programação não-linear é usda para determinar uma carteira que, sob certas hipóteses, forneça uma relação ótima entre esses dois fatores.

Essa metodologia se baseia em grande parte sobre a pesquisa revolucionária feita por Harry Markowitz e William Sharpe que lhes conferiu o Prêmio Nobel de Economia do ano de 1990.

Um modelo de programação não-linear pode ser formulado para esse problema como mostrado a seguir. Suponha que sejam consideradas \(n\) ações (títulos) para inclusão nessa carteira e façamos que as variáveis de escolha \(x_{j}(j=1,2,...,n)\) representem o número de cotas das ações \(j\) a serem incluídas. Estipulamos que \(\mu_{j}\) e \(\sigma_{jj}\) sejam, respectivamente, a média e variância, (estimadas) do retorno sobre cada ação \(j\), em que \(\sigma_{jj}\) mede o risco dessa ação. Para \(i=1,2,...,n\) (\(i\neq j\)), façamos que \(\sigma_{ij}\), a metodologia usual é partir de certas hipóteses sobre o comportamento do mercado que nos permitam calcular \(\sigma_{ij}\) diretamente de \(\sigma_{ii}\) e \(\sigma_{jj}\). A seguir, o valor esperado \(R(x)\) e variância \(V(x)\) do retorno total de toda a carteira são:

\[ R(x)=\sum _{ j=1 }^{ n }{ { \mu }_{ j }{ x }_{ j } } \] \[ V(x)=\sum _{ i=1 }^{ n }{ \sum _{ j=1 }^{ n }{ { \sigma }_{ ij }{ x }_{ i }{ x }_{ j } } } \] em que \(V(x)\) mede o risco associado à carteira. Uma maneira de se considerar a relação conflitante entre esses dois fatores é usar \(V(x)\) como função objetivo a ser minimizada e, depois, impor a restrição de que \(R(x)\) não pode ser menor que o retorno mínimo esperado aceitável. O modelo de programação não-linear completo ficaria então:

\[ \begin{aligned} & \text{Minimizar} & & V(\boldsymbol{x})=\sum_{i=1}^{n}{\sum_{j=1}^{n}{{\sigma}_{ij}{x}_{i}{x}_{j}}} \\ & \text{s.a.} & & \sum_{j=1}^{n}{{\mu}_{j}{x}_{j}} \geq L \\ &&& \sum_{j=1}^{n}{P_{j}{x}_{j}} \leq B \\ &&& x_{j} \geq 0 && \text{para j=1,2,...,n} \end{aligned} \] em que \(L\) é o retorno mínimo esperado aceitável, \(P_{j}\) é o preço para cada cota da ação \(j\) e \(B\) o volume de dinheiro previsto para a carteira.

REPRESENTAÇÃO GRÁFICA

Quando um problema de programação não-linear tem apenas uma ou duas variáveis, ele pode ser representado graficamente de modo muito parecido com o exemplo do problema de programação linear apresentado neste link.

TIPOS DE PROBLEMAS DE PROGRAMAÇÃO NÃO-LINEAR

Os problemas de programação não-linear se apresentam em muitas formas e formatos diferentes. Ao contrário do método SIMPLEX para programação linear, não existe um algoritmo único capaz de resolver todos esses tipos de problemas.

Em vez disso, foram desenvolvidos algoritmos para várias classes individuais de problemas de programação não-linear. Em seguida, introduzimos brevemente algumas destas classes e como elas podem ser resolvidas.

• OTIMIZAÇÃO LINEARMENTE RESTRITA

Problemas de otimização linearmente restrita são caracterizados por restrições que se ajustam completamente à programação linear, de modo que todas as funções de restrição \(G_{i}(\boldsymbol{x})\) sejam lineares, porém a função objetivo seja não-linear. Foi desenvolvida uma série de algoritmos especiais baseados na extensão do método SIMPLEX para considerar a função objetivo não-linear. Um importante caso especial, que consideramos a seguir, é a programação quadrática.

• PROGRAMAÇÃO QUADRÁTICA

Problemas de programação quadrática novamente possuem restrições lineares. No entanto, agora a função objetivo deve ser quadrática. Portanto, a única diferença entre um problema destes e um problema de programação linear é que alguns dos termos na função objetivo envolvem o quadrado de uma variável ou o produto de duas variáveis.

Foram desenvolvidos diversos algoritmos para esse caso sob a hipótese adicional de que a função objetivo seja uma função côncava. Um exemplo de aplicação da programação quadrática é o problema da seleção de carteira com ativos de risco.

• PROGRAMAÇÃO CONVEXA

A programação convexa cobre ampla gama de problemas que engloba como casos especiais todos os tipos precedentes quando a função objetivo é uma função côncava a ser maximizada. As hipóteses são:

1. A função objetivo é uma função côncava
2. Cada restrição é uma função convexa

• PROGRAMAÇÃO SEPARÁVEL

A programação separável é um caso especial de programação convexa, em que a única hipótese adicional é que todas as funções (objetivo e restrições) sejam funções separáveis.

Uma função separável é uma função na qual cada termo envolve apenas uma única variável, de modo que a função seja separável em uma soma de funções de variáveis individuais. Por exemplo, \(f(x_{1},x_{2})=126x_{1}-9x_{1}^{2}+182x_{2}-13x_{2}^{2}\) é uma função separável, pois ela pode ser expressa como \(f(x_{1},x_{2})=f(x_{1})+f(x_{2})\).

• PROGRAMAÇÃO NÃO-CONVEXA

A programação não-convexa engloba problemas de programação não-linear que não satisfazem as hipóteses de programação convexa. Certos tipos de problemas de programação não-convexa podem ser resolvidos sem grandes dificuldades por métodos especiais. Dois tipos desses são discutivos brevemente a seguir.

• PROGRAMAÇÃO GEOMÉTRICA

Ao aplicar a programação não-linear a problemas de engenharia, economia e estatística, a função objetivo e as funções de restrição assumem frequentemente a forma:

\[ G(\boldsymbol{x}) = \sum _{i=1}^{N}{{c}_{i}{P}_{i}(\boldsymbol{x})} \] em que

\[ P_{i}(\boldsymbol{x}) = x_{1}^{a_{i1}}x_{2}^{a_{i2}}...x_{n}^{a_{in}} \]

para \(i=1,2,...,N\). Em tais casos, \(c_{i}\) e \(a_{ij}\) representam tipicamente constantes físicas e \(x_{j}\) são variáveis de projeto. Essas funções geralmente não são convexas nem côncavas e, portanto, as técnicas de programação convexa não podem ser aplicadas diretamente a esses problemas de programação geométrica.

• PROGRAMAÇÃO FRACIONÁRIA

Suponha que a função objetivo se encontre na forma de uma fração, isto é, a razão de duas funções:

\[ \begin{aligned} & \text{Maximizar} & & f(\boldsymbol{x})=\frac{f_{1}(\boldsymbol{x})}{f_{2}(\boldsymbol{x})} \end{aligned} \] Tais problemas de programação fracionária surgem, por exemplo, quando se está maximizando a razão entre produção e horas de mão-de-obra gastas (produtividade) ou entre lucro e capital investido (taxa de retorno) ou ainda entre valor esperado e desvio-padrão de alguma medida de desempenho para uma carteira de investimentos (retorno/risco).

CONDIÇÕES DE KUHN-TUCKER

No problema clássico de otimização, sem nenhuma restrição explícita aos sinais das variáveis de escolha e sem nenhuma desigualdade nas restrições, a condição de primeira ordem para um extremo relativo ou local é simplesmente que as derivadas parciais primeiras da função de Lagrange em relação a todas as variáveis de escolha e os multiplicadores de Lagrange sejam iguais a zero.

Em programação não-linear existe um tipo semelhante de condição de primeira ordem, conhecida como condições de Kuhn-Tucker (Kuhn and Tucker (2014)). Contudo, como veremos, enquanto a condição de primeira orde clássica é sempre necessária, não se pode conceder às condições de Kuhn-Tucker o status de condições necessárias a menos que cumpram uma certa hipótese.

• EFEITO DE RESTRIÇÕES DE NÃO-NEGATIVIDADE

Considere um problema com restrições de não-negatividade nas variáveis de escolha, mas sem nenhuma outra restrição. Para o caso de uma variável, temos:

\[ \begin{aligned} & \text{Maximize} & & \pi=f(x_{1}) \\ & \text{s.a.} & & x_{1} \geq 0 \end{aligned} \]

onde supõe-se que a função \(f\) é diferenciável. Em vista da restrição \(x_{1} \geq 0\), podem surgir três situações. Primeira, se ocorrer um máximo local de \(\pi\) no interior da região viável da figura \((a)\) abaixo, tal como o ponto \(A\), então temos uma solução interior. A condição de primeira ordem neste caso é \(\frac{d\pi}{dx_{1}}=f^{'}(x_{1})=0\), a mesma do problema clássico de otimização. Segunda, como ilustrado pelo ponto \(B\) na figura abaixo, um máximo local também pode ocorrer no eixo vertical, onde \(x_{1}=0\). Mesmo neste segundo caso, onde temos uma solução de fronteira, a condição de primeira ordem \(f^{'}(x_{1})=0\) permanece válida. Contudo, há uma terceira possibilidade, ou seja, no presente contexto, um máximo local pode ocorrer no ponto \(C\) ou no ponto \(D\) da figura abaixo porque, para se qualificar como um máximo local no problema, basta que o ponto candidato seja mais alto que os pontos vizinhos dentro da região viável.

Em vista desta última possibilidade, o ponto máximo em um problema como o proposto pode ser caracterizado não apenas pela equação \(f^{'}(x_{1})=0\), mas também pela desigualdade \(f^{'}(x_{1})<0\). Por outro lado, note que a desigualdade oposta \(f^{'}(x_{1})>0\) pode ser excluída com segurança, pois em um ponto onde a inclinação da curva é ascendente, nunca podemos ter um máximo (como no ponto \(E\)). Assim, podemos resumir as condições para que \(x_{1}\) dê um máximo local de \(\pi\) no problema em:

\[ \begin{aligned} f^{'}(x_{1})<0 && x_{1}\geq 0 && \text{e} && x_{1}f^{'}(x_{1})=0 \end{aligned} \]

• EFEITO DE RESTRIÇÕES DE DESIGUALDADE

Por simplicidade, em primeiro lugar vamos tratar de uma problema com três variáveis de escolha (\(n=3\)) e duas restrições (\(m=2\)):

\[ \begin{aligned} & \text{Maximize} & & \pi = f(x_{1},x_{2},x_{3}) \\ & \text{s.a.} & & G^{1}(x_{1},x_{2},x_{3}) \leq r_{1} \\ &&& G^{2}(x_{1},x_{2},x_{3}) \leq r_{2} \\ &&& x_{1},x_{2},x_{3} \geq 0 \end{aligned} \] que, com o auxílio de duas novas variáveis \(s_{1}\) e \(s_{2}\), pode ser transformada na forma equivalente:

\[ \begin{aligned} & \text{Maximize} & & \pi = f(x_{1},x_{2},x_{3}) \\ & \text{s.a.} & & G^{1}(x_{1},x_{2},x_{3}) + s_{1} = r_{1} \\ &&& G^{2}(x_{1},x_{2},x_{3}) + s_{2} = r_{2} \\ &&& x_{1},x_{2},x_{3},s_{1},s_{2} \geq 0 \end{aligned} \]

Se as restrições de não-negatividade estiverem ausente, podemos, em conformidade com a abordagem clássica, formar a função Lagrange:

\[ Z = f(x_{1},x_{2},x_{3}) + \lambda_{1}[r_{1}-G^{1}(x_{1},x_{2},x_{3}) - s_{1}] + \lambda_{2}[r_{1}-G^{2}(x_{1},x_{2},x_{3}) - s_{2}] \] e escrever a condição de primeira ordem como:

\[ \frac{dZ}{dx_{1}}=\frac{dZ}{dx_{2}}=\frac{dZ}{dx_{3}}=\frac{dZ}{ds_{1}}=\frac{dZ}{ds_{2}}=\frac{dZ}{d\lambda_{1}}=\frac{dZ}{d\lambda_{2}}=0 \] Mas visto que as variáveis \(x_{j}\) e \(s_{i}\) têm de ser obrigatoriamente não-negativas, a condição de primeira ordem para essas variáveis deve ser modificada de acordo com o problema de não-negatividade. Ou seja,

\[ \begin{aligned} & \frac{dZ}{dx_{j}} \leq 0 && x_{j}\geq 0 && \text{e} && x_{j}\frac{dZ}{dx_{j}}=0 \\ & \frac{dZ}{ds_{i}} \leq 0 && s_{i}\geq 0 && \text{e} && s_{i}\frac{dZ}{ds_{i}}=0 \\ & \frac{dZ}{d \lambda_{i}}=0 && \text{para i=1,2} && \text{e} && \text{para j=1,2,3} \end{aligned} \]

Cada linha acima está relacionada a um tipo diferente de variável. Mas podemos consolidar as duas últimas linhas e, no processo, eliminar a nova variável \(s_{i}\) da condição de primeira ordem. Considerando que \({dZ}/{d}{s}_{i}=-\lambda_{i}\), a segunda linha nos diz que devemos ter \(-\lambda_{i}\leq0\), \(s_{i}\geq0\) e \(-s_{i}\lambda_{i}=0\), ou de modo equivalente:

\[ \begin{aligned} s_{i}\geq0 && \lambda_{i}\geq0 && \text{e} && s_{i}\lambda_{i}=0 \end{aligned} \] Mas a terceira linha significa que \(s_{i}=r_{i}-G^{i}(x_{1},x_{2},x_{3})\). Assim, a restrição se torna:

\[ \begin{aligned} r_{i}-G^{i}(x_{1},x_{2},x_{3})\geq0 && \lambda_{i}\geq0 && \text{e} && \lambda_{i}[r_{i}-G^{i}(x_{1},x_{2},x_{3})]=0 \end{aligned} \]

Por fim, podemos expressar a condição de primeira ordem em uma forma equivalente sem as novas variáveis. Usando o símbolo \(G^{i}_{j}\) para denotar \({dG^{i}}/{d}{x}_{j}\), escrevemos agora:

\[ \begin{aligned} & \frac{dZ}{dx_{j}} = f_{j} - (\lambda_{1}G^{1}_{j}+\lambda_{2}G^{2}_{j}) \leq 0 && x_{j}\geq 0 && \text{e} && x_{j}\frac{dZ}{dx_{j}}=0 \\ & r_{i}-G^{i}(x_{1},x_{2},x_{3})\geq0 && \lambda_{i}\geq 0 && \text{e} && \lambda_{i}[r_{i}-G^{i}(x_{1},x_{2},x_{3})]=0 \end{aligned} \] São essas as condições de Kuhn-Tucker para o problema proposto.

• EXEMPLO

Se formularmos o problema familiar de maximização de utilidade segundo o modelo da programação não-linear, podemos ter um problema com a restrição de desigualdade, como segue:

\[ \begin{aligned} & \text{Maximize} & & U = xy \\ & \text{s.a.} & & x + y \leq 100 \\ &&& x \leq 40 \\ &&& x,y \geq 0 \end{aligned} \] Note que com a restrição de desigualdade, o consumidor já não é mais obrigado a gastar toda a quantia na compra dos dois bens. Assim, a função de Lagrange se torna:

\[ Z = xy + \lambda_{1}(100-x-y) + \lambda_{2}(40-x) \] e as condições de Kuhn-Tucker se tornam:

\[ \begin{aligned} & Z_{x} = y -\lambda_{1} - \lambda_{2}\leq 0 && x\geq 0 && \text{e} && xZ_{x}=0 \\ & Z_{y} = x -\lambda_{1}\leq 0 && y\geq 0 && \text{e} && yZ_{y}=0 \\ & Z_{\lambda_{1}} = 100 -x -y \geq 0 && \lambda_{1}\geq 0 && \text{e} && \lambda_{1}Z_{\lambda_{1}}=0 \\ & Z_{\lambda_{2}} = 40 -x \geq 0 && \lambda_{2}\geq 0 && \text{e} && \lambda_{2}Z_{\lambda_{2}}=0 \end{aligned} \] A abordagem típica para resolver um problema de programação não-linear é a de tentativa e erro. Para o presente exemplo, não faz sentido experimentar \(x=0\) ou \(y=0\), pois teríamos \(U=xy=0\). Portanto, vamos supor que ambos, \(x\) e \(y\), são diferentes de zero e deduzir que \(Z_{x}=Z_{y}=0\) pela folga complementar, o que significa que:

\[ y-\lambda_{1}-\lambda_{2}=x-\lambda_{1}(=0) \] de modo que

\[ y-\lambda_{2}=x \] Agora, suponha que a restrição de racionamento seja não-vinculadora na solução, o que implica que \(\lambda_{2}=0\). Então temos \(x=y\) e o orçamento (\(100\)) resulta na solução experimental \(x=y=50\). Mas essa solução viola a restrição de racionamento \(x\leq40\). Por conseguinte, temos de adotar a hipótese alternativa de que a restrição de racionamento é vinculadora com \(x^{\ast}=40\). Então, a restrição orçamentária permite que o consumidor tenha \(y^{\ast}=60\). Além disso, visto que a folga complementar determina que \(Z_{x}=Z_{y}=0\), podemos calcular, de imediato, que \(\lambda_{1}^{\ast}=40\) e \(\lambda_{2}^{\ast}=20\)

RESOLVENDO PROBLEMAS DE PROGRAMAÇÃO NÃO-LINEAR NO R

No R, temos o pacote Rsolnp que fornece a função solnp() que resolve problemas gerais de programação não-linear. Assim, vamos usar este pacote para resolver exemplos de problemas de programação não-linear no R.

1. Considere o seguinte problema de minimização (Programação Quadrática):

\[ \begin{aligned} & \text{Minimize} & & f(x,y) = 4x^{2} + 10y^{2} \\ & \text{s.a.} & & 0 \leq x^{2} + y^{2} \leq 4 \end{aligned} \] Tal problema pode se adicionado no R, da seguinte forma:

##########################
####     PACOTES     #####
##########################
# Instalar pacotes necessários 
# install.packages("Rsolnp")
# Carregar pacotes necessários para o restante do documento
suppressMessages(require(Rsolnp))
##########################
####     PROBMELA    #####
##########################
# Função Objetivo
fn <- function(x) { 
  4*x[1]^2 + 10*x[2]^2 +5
}
# Restrição 1: x^2+y^2 <= 4
ineq1 <- function(x) { 
  z1=x[1]^2 + x[2]^2
  return(c(z1))
}
# Limite inferior (lower) e superior (upper) das restrições de desigualdade
lh <- c(0)
uh <- c(4)
# Valores iniciais para o algoritmo
x0 <- c(1, 1) 
##########################
####     SOLUÇÃO     #####
##########################
# Basicamente, usamos a função solnp do pacote Rsolnp com os seguintes parâmetros:
# pars: que recebe o vetor de parâmetros iniciais para a solução
# fun: que recebe a função objetivo
# ineqfun: que recebe a função de restrição
# ineqLB: que recebe o limite inferior da restrição de desigualdade
# ineqUB: que recebe o limite superior da restrição de desigualdade
# mais opções da função podem ser obtidas por meio do help(solnp)
solucao.problema <- Rsolnp::solnp(pars = x0, 
                                 fun = fn, 
                                 ineqfun = ineq1, 
                                 ineqLB = lh, 
                                 ineqUB=uh)

Iter: 1 fn: 7.8697   Pars:  0.68437 0.31563
Iter: 2 fn: 5.6456   Pars:  0.39701 0.03895
Iter: 3 fn: 5.1604   Pars:  0.200217 0.002001
Iter: 4 fn: 5.0401   Pars:  0.10011821 0.00005323
Iter: 5 fn: 5.0100   Pars:  0.0500592618 0.0000006781
Iter: 6 fn: 5.0025   Pars:   0.02502983706 -0.00000004425
Iter: 7 fn: 5.0006   Pars:   0.01251500215 -0.00000005034
Iter: 8 fn: 5.0002   Pars:   0.00625757145 -0.00000005045
Iter: 9 fn: 5.0000   Pars:   0.00312915970 -0.00000004968
Iter: 10 fn: 5.0000  Pars:   0.00156561388 -0.00000004983
Iter: 11 fn: 5.0000  Pars:   0.0007831473 -0.0000000508
Iter: 12 fn: 5.0000  Pars:   0.00039896484 -0.00000005045
Iter: 13 fn: 5.0000  Pars:   0.00021282342 -0.00000004897
Iter: 14 fn: 5.0000  Pars:   0.00014285437 -0.00000004926
Iter: 15 fn: 5.0000  Pars:   0.00011892066 -0.00000004976
solnp--> Completed in 15 iterations

Como resultado, temos que o algoritmo precisou de 15 iterações pra encontrar a solução do problema. Podemos verificar o resultado da função objetivo em cada uma das iterações. Para tanto, basta fazer:

solucao.problema$values

 [1] 19.000000  7.869675  5.645626  5.160388  5.040095  5.010024  5.002506  5.000627  5.000157  5.000039
[11]  5.000010  5.000002  5.000001  5.000000  5.000000  5.000000

O que nos mostra que a partir da iteração 14 a função objetivo não alterou seu valor e por isso o algoritmo parou na iteração 15. Já a solução para \(x_{1}\) e \(x_{2}\) pode ser

Podemos alterar a tolerância para que o algorimo pare as iterações ou até mesmo optar por não mostrar os resultados de cada iteração. Para tanto, basta adicionar a opção control como abaixo:

# Adicionar a tolerância para convergência e não mostrar os resultados
# de cada iteração no console do R (trace=0)
ctrl <- list(TOL = 1e-15, trace = 0)


solucao.problema2 <- Rsolnp::solnp(pars = x0, 
                                 fun = fn, 
                                 ineqfun = ineq1, 
                                 ineqLB = lh, 
                                 ineqUB=uh, 
                                 control = ctrl)

# Para ver os valore da função objetivo em cada iteração
solucao.problema2$values

# Para saber a solução 
solucao.problema2$pars

2. Outro exemplo:

\[ \begin{aligned} & \text{Minimize} & & f(\boldsymbol{x}) = -x_{1}x_{2}x_{3} \\ & \text{s.a.} & & 4x_{1}x_{2} + 2x_{2}x_{3} + 2x_{3}x_{1} = 100 \\ &&& 1 \leq x_{i} \leq10 & \text{i=1,2,3} \end{aligned} \]

Tal problema pode se adicionado no R, da seguinte forma:

##########################
####     PROBMELA    #####
##########################
# Função Objetivo
fn2 <- function(x, ...){
  -x[1]*x[2]*x[3]
}
# Restrição 1: 
eqn <- function(x, ...){
    4*x[1]*x[2]+2*x[2]*x[3]+2*x[3]*x[1]
}
# Limite da restrição
constraints <- c(100)
# Limite inferior (lower) e superior (upper) da restrição de desigualdade
lx <- rep(1, 3)
ux <- rep(10, 3)
# Valores iniciais para o algoritmo
pars <- c(2, 1, 7)
##########################
####     SOLUÇÃO     #####
##########################
# Restrições de tolerância e não mostrar o resultado de cada iteração no console
ctrl2 <- list(TOL = 1e-6, trace = 0)
# Basicamente, usamos a função solnp do pacote Rsolnp com os seguintes parâmetros:
# pars: que recebe o vetor de parâmetros iniciais para a solução
# fun: que recebe a função objetivo
# eqfun: que recebe a função de restrição de igualdade
# eqB: a igualdade da restrição de igualdade
# LB: limite inferior da restrição de desigualdade
# UB: limite superior da restrição de desigualdade
# control: as opções de tolerância e mostrar resultados
# mais opções da função podem ser obtidas por meio do help(solnp)
solucao.problema2 <- Rsolnp::solnp(pars = pars, 
                                 fun = fn2, 
                                 eqfun = eqn,
                                 eqB = constraints,
                                 LB = lx,
                                 UB = ux,
                                 control = ctrl)
# Valores da função objetivo em cada iteração
solucao.problema2$values

 [1] -14.00000 -52.58442 -46.78681 -48.05588 -48.11152 -48.11249 -48.11250 -48.11250 -48.11250 -48.11250
[11] -48.11250

# Solução  
solucao.problema2$pars

[1] 2.885893 2.884811 5.779102

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.

Kuhn, Harold W, and Albert W Tucker. 2014. Nonlinear Programming. Springer.

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