Para resolvermos o sistema de equações não lineares proposto, podemos usar a biblioteca "scipy", a qual possui diversas ferramentas elaboradas para as área de matemática (como otimização, integração, entre outros). O método empregado será o de otimização a partir da técnica "fsolve". Esta técnica aproxima a função objetivo \(f(x)\) de 0, retornando, assim, o valor de "\(x\)" que retorna \(f(x)=0\); i.e., a raiz da função.
Primeiro, define-se um possível valor para "\(x\)" e, a partir dele, chega-se ao valor verdadeiro (dentro do erro tolerado). Por padrão, a tolerância de erro é de \(1.49012e-08\), mas há a possibilidade de alterá-lo. A implementação em Python é a seguinte:
#importa as bibliotecas necessárias
import numpy as np
import scipy
from scipy import optimize
from optimize import fsolve
A técnica de fsolve aceita apenas 1 função como input. Desta forma, para podermos trabalhar com tal método num cenário com múltiplas funções, devemos usar vetores:
# definimos a função "f" que vai entrar como input no fsolve
# definimos também todas as variáveis "x", além de "R" e "S"
def f(abcdefghij):
x1 = abcdefghijl[0]
x2 = abcdefghijl[1]
x3 = abcdefghijl[2]
x4 = abcdefghijl[3]
x5 = abcdefghijl[4]
x6 = abcdefghijl[5]
x7 = abcdefghijl[6]
x8 = abcdefghijl[7]
x9 = abcdefghijl[8]
x10 = abcdefghijl[9]
R = 4.056734
S = abcdefghijl[10]
#organizamos as funções de modo a torná-las no formato f(x)=0
#cada uma dessas funções ocupará um slot do vetor de funções "f"
f0 = x1 + x4
f1 = 2*x1 + x2 + x4 + x7 + x8 + x9 + 2*x10 - R - 10
f2 = 2*x2 + 2*x5 + x6 +x7 - 8
f3 = 2*x3 + x5 - 4*R
f4 = x1*x5 - 0.193*x2*x4
f5 = x6*np.sqrt(abs(x2)) - 0.002597*np.sqrt(abs(x2*x4*S))
f6 = x7*np.sqrt(abs(x4)) - 0.003448*np.sqrt(abs(x1*x4*S))
f7 = x4*x8 - 0.00001799*x2*S
f8 = x4*x9 - 0.0002155*x1*np.sqrt(abs(x3*S))
f9 = (x4**2)*(x10 - 0.00003846*S)
f10 = S - x1 - x2 - x3 - x4 - x5 - x6 - x7 - x8 - x9 - x10
#criação do vetor f
return np.array([f0, f1, f2, f3, f4, f5, f6, f7, f8, f9,f10])
#damos um chute inicial para a suposta raiz (para cada função)
chute_abcdefghijl = np.array([0,0,0,0,0,0,0,0,0,0,0])
#por fim, resolvemos o sistema
abcdefghij = fsolve(f, chute_abcdefghij)
x1 = abcdefghijl[0]
x2 = abcdefghijl[1]
x3 = abcdefghijl[2]
x4 = abcdefghijl[3]
x5 = abcdefghijl[4]
x6 = abcdefghijl[5]
x7 = abcdefghijl[6]
x8 = abcdefghijl[7]
x9 = abcdefghijl[8]
x10 = abcdefghijl[9]
S=abcdefghijl[10]
Após rodarmos o código acima, podemos exibir a solução de x e o valor de f quando empregamos tal vetor "\(x\)" de soluções.
print(x1,x2,x3,x4,x5,x6,x7,x8,x9,x10,S)
--------------
Output
--------------
[ [3.000000010727565] ,[3.999999347453441], [8.113468001378202],
[-1.0723254607500187e- 08], [-2.758677545712311e-09], [5.371916497930608e-11],
[1.3105568356247757e-06], [0.020042985282166775], [-34.3037135501549],
[19.170201948066815], [3.9909073325860474e-08]]
print(f(abcdefghijl))
---------------
Output
---------------
[ 4.31032987e-12 3.04822834e-12 8.17124146e-14 -2.27373675e-12
2.31853976e-12 -1.03479307e-14 1.21667628e-11 -2.17797891e-10
-3.37642850e-11 2.20434681e-15 2.71640488e-11]
O método foi bem sucedido porque podemos observar que as funções tendem a zero quando aplicamos o conjunto de soluções obtido.