<jupyter_start><jupyter_text>Trabalho Prático Parte 1<jupyter_code>import numpy as np
import math<jupyter_output><empty_output><jupyter_text>Questão 1Calcule as abscissas $t_i$ e os pesos $w_i$ via a matriz de Jacobi.<jupyter_code>def jacobi(n):    
    # Iniciar a matriz J
    J = np.zeros((n,n))
    # Calcular autovalores e autovetores
    for i in range(1,n):
        J[i-1,i] = math.sqrt((i**2)/((4*i**2)-1))
        J[i,i-1] = math.sqrt((i**2)/((4*i**2)-1))
    # Ordenar em ordem decrescente do autovalor
    eigenValues, eigenVectors = np.linalg.eig(J)
    idx = eigenValues.argsort()[::-1]
    # Calcular w
    w = np.zeros(eigenValues.shape[0])
    t = np.zeros(w.shape)
    # Retornar t e w como vetores de dimensões 1 x n
    for i in range(eigenValues.shape[0]):
        index = idx[i]
        t[i] = eigenValues[index]
        vector = eigenVectors[:,index]/np.linalg.norm(eigenVectors[:,index])
        w[i] = 2*(vector[0]**2)
    return t, w

jacobi(3)
ans2 = ([ 0.57735027, -0.57735027], [0.9999999999999998, 0.9999999999999998])
ans3 = ([ 7.74596669e-01, -4.78946310e-17, -7.74596669e-01], [0.5555555555555551, 0.8888888888888894, 0.5555555555555556])
ans4 = ([ 0.86113631,  0.33998104, -0.33998104, -0.86113631], [0.3478548451374544, 0.652145154862546, 0.6521451548625463, 0.3478548451374541])
assert np.allclose(ans2, jacobi(2))
assert np.allclose(ans3, jacobi(3))
assert np.allclose(ans4, jacobi(4))<jupyter_output><empty_output><jupyter_text>Inicie os vetores ```difTab2```, ```difTab3``` e ```difTab4``` com as diferenças entre os $t$s e $w$s encontrados para $n=2,3,4$ com os valores tabelados.<jupyter_code>#difTab3[0][0] guarda t[0] - t0 tabelado pra n=3
#difTab3[0][1] guarda t[1] - t1 tabelado pra n=3
#difTab3[0][2] guarda t[2] - t2 tabelado pra n=3
#
#difTab3[1][0] guarda w[0] - w0 tabelado pra n=3
#difTab3[1][1] guarda w[1] - w1 tabelado pra n=3
#difTab3[1][2] guarda w[2] - w2 tabelado pra n=3
#...

j2 = jacobi(2)
difTab2 = np.zeros((2,2))
for i in range(difTab2.shape[0]):
    for j in range(difTab2.shape[1]):
        difTab2[i,j] = j2[i][j]-ans2[i][j]

j3 = jacobi(3)
difTab3 = np.zeros((2,3))
for i in range(difTab3.shape[0]):
    for j in range(difTab3.shape[1]):
        difTab3[i,j] = j3[i][j]-ans3[i][j]
        
j4 = jacobi(4)
difTab4 = np.zeros((2,4))
for i in range(difTab4.shape[0]):
    for j in range(difTab4.shape[1]):
        difTab4[i,j] = j4[i][j]-ans4[i][j]
print("difTab2: ", difTab2, "\n")
print("difTab3: ", difTab3, "\n")
print("difTab4: ", difTab4, "\n")<jupyter_output>difTab2:  [[-8.10374323e-10  8.10374323e-10]
 [ 4.44089210e-16  4.44089210e-16]] 

difTab3:  [[ 2.41483278e-10  3.04528413e-26 -2.41483500e-10]
 [ 0.00000000e+00  0.00000000e+00  0.00000000e+00]] 

difTab4:  [[ 1.59405245e-09  3.58485636e-09 -3.58485625e-09 -1.59405289e-09]
 [ 0.00000000e+00  0.00000000e+00  2.22044605e-16  0.00000000e+00]]<jupyter_text>Questão 2<jupyter_code>print(jacobi(2))
print(jacobi(3))
print(jacobi(4))<jupyter_output>(array([ 0.57735027, -0.57735027]), array([1., 1.]))
(array([ 7.74596669e-01, -4.78946310e-17, -7.74596669e-01]), array([0.55555556, 0.88888889, 0.55555556]))
(array([ 0.86113631,  0.33998104, -0.33998104, -0.86113631]), array([0.34785485, 0.65214515, 0.65214515, 0.34785485]))<jupyter_text>Porque para $n=2,3,4$ a soma dos pesos é igual a 2? > Porque, como os pesos são dados como `2*v_1,i²`, temos um 2 multiplicando-os e, como a soma dos `v_1,i²` sempre dará 1, quando multiplicamos isso por 2, sempre teremos 2.  Questão 3Escreva uma função para calcular a integral pela quadratura de Gauss-Legendre.<jupyter_code># y é um vetor 1 x n em que y[i]=f(x[i])
# w é o vetor 1 x n obtido com a função jacobi
def gaussLegendre(y, n, a, b, w):
    GL = 0
    for i in range(n):
        GL += y[i]*w[i]
    return GL*(b-a)/2<jupyter_output><empty_output><jupyter_text>Calcule $\int_0^2(x^5-x^3+x-1)dx$ usando $n=2$ na função de Gauss-Legendre que você criou.<jupyter_code>def get_w_and_y_3(a, b, n):
    t, w = jacobi(n)
    n = t.shape[0]
    x = np.zeros(n)
    y = x.copy()
    for i in range(n):
        x[i] = (((b-a)*t[i]) + a + b)/2
        y[i] = x[i]**5 - x[i]**3 + x[i] -1
    return w,y

#intGL2 = 
a = 0
b = 2
n = 2
w, y = get_w_and_y_3(a, b, n)
intGL2 = gaussLegendre(y,n,a,b,w)
assert np.isclose(5.777777777777776, intGL2)<jupyter_output><empty_output><jupyter_text>Calcule $\int_0^2(x^5-x^3+x-1)dx$ usando $n=3$ na função de Gauss-Legendre que você criou.<jupyter_code>#intGL3 = 
a = 0
b = 2
n = 3
w, y = get_w_and_y_3(a, b, n)
intGL3 = gaussLegendre(y,n,a,b,w)
assert np.isclose(6.6666666666666625, intGL3)<jupyter_output><empty_output><jupyter_text>Calcule $\int_0^2(x^5-x^3+x-1)dx$ usando $n=4$ na função de Gauss-Legendre que você criou.<jupyter_code>#intGL4 = 
a = 0
b = 2
n = 4
w, y = get_w_and_y_3(a, b, n)
intGL4 = gaussLegendre(y,n,a,b,w)
assert np.isclose(6.666666666666674, intGL4)<jupyter_output><empty_output><jupyter_text>Explique os resultados obtidos para $\int_0^2 (x^5-x^3+x-1) dx$ com $n = 2,3,4$. > De acordo com o WolframAlpha, temos que o resultado exato dessa integral sendo igual a 6.666666666666667 (arredondando o último 7). >>O que podemos perceber, portanto, é que: quanto mais crescemos o valor de n, mais nos aproximamos do valor exato da integral. E observamos, também, que mesmo com um n não tão grande (4), chegamos em um valor consideravelmente razoável como solução perfeita da integral.   Questão 4Qual o valor exato de $\int_0^\pi \sin(x) dx$?<jupyter_code>import scipy.integrate as integrate

#exact = 
exact = integrate.quad(lambda x: math.sin(x), 0, math.pi)[0]
exact<jupyter_output><empty_output><jupyter_text>Inicie o vetor ```difExac``` com as diferenças entre os valores encontrados para $n=3,4,5$ e o valor exato.<jupyter_code>#difExac[0] guarda exact - resultado pra n=3
#difExac[1] guarda exact - resultado pra n=4
#difExac[2] guarda exact - resultado pra n=5
#difExac =

def get_w_and_y_4(a, b, n):
    t, w = jacobi(n)
    n = t.shape[0]
    x = np.zeros(n)
    y = x.copy()
    for i in range(n):
        x[i] = (((b-a)*t[i]) + a + b)/2
        y[i] = math.sin(x[i])
    return w,y

a = 0
b = math.pi
difExac = np.zeros(3)

for i in range(difExac.size):
    n = i+2
    w, y = get_w_and_y_4(a,b, n)
    difExac[i] = exact - gaussLegendre(y, n, a, b, w)
print(difExac)<jupyter_output>[ 6.41804253e-02 -1.38891361e-03  1.57715423e-05]<jupyter_text>Questão 5Seja $f(x)=e^x$. Avalie $f(x)$ em $x_0=-\frac{\sqrt{3}}{3}$ e $x_1=\frac{\sqrt{3}}{3}$.<jupyter_code>x = np.zeros(2)
y = x.copy()

x[0] = -(math.sqrt(3)/3)
x[1] = (-1)*x[0]

#y[0] guarda f(x0) e y[1] guarda f(x1)
for i in range(y.size):
    y[i] = math.exp(x[i])
print(y)<jupyter_output>[0.56138391 1.78131217]<jupyter_text>Determine o polinômio linear $p(x)$ que passa pelos pontos ($x_0$,y[0]) e ($x_1$,y[1]).<jupyter_code>#p = 
p = np.zeros(2)

#p[1] guarda o coeficiente de x^1
p[1] = (y[1]-y[0])/(x[1]-x[0])
#p[0] guarda o coeficiente de x^0
p[0] = y[0]-p[1]*x[0]
print(p)<jupyter_output>[1.17134804 1.05648886]<jupyter_text>Calcule analiticamente $\int_{-1}^1p(x)dx$.<jupyter_code>#integAn =

integAn = (p[1]/2 + p[0]) - (p[1]/2 - p[0])
integAn<jupyter_output><empty_output><jupyter_text>Agora calcule $\int_{-1}^1e^xdx$ usando $n=2$ na função de Gauss-Legendre que você criou.<jupyter_code>#integGL =
a = -1
b = 1
n = 2

def get_w_and_y_5(a, b, n):
    t, w = jacobi(n)
    n = t.shape[0]
    x = np.zeros(n)
    y = x.copy()
    for i in range(n):
        x[i] = (((b-a)*t[i]) + a + b)/2
        y[i] = np.exp(x[i])
    return w,y

w,y = get_w_and_y_5(a, b, n)
integGL = gaussLegendre(y, n, a, b, w)
integGL
print(integGL - integAn)<jupyter_output>8.881784197001252e-16<jupyter_text>Explique os resultados. > Nessa questão, conseguimos observar que, tanto a solução analitica da integral pelo polinômio linear p(x) quanto pela função de Gauss-Legendre construida na questão 3, obtivemos valores extremamente próximos, na casa de 10x(-16). O que para a nossa análise é super tranquilo tratá-los como o mesmo resultado. >> Entretando, realizando a resolução exata da equação, temos:<jupyter_code>resp_exata = integrate.quad(lambda x: np.exp(x), -1, 1)[0]
print("Valor exato =", resp_exata)
print("Diferença para o cálculo exato =", resp_exata-integGL)<jupyter_output>Valor exato = 2.3504023872876028
Diferença para o cálculo exato = 0.007706299377871595<jupyter_text>> Podemos ver que, quando comparado ao valor exato, já não temos uma aproximação tão boa assim. Isso pode ser explicado pois, para calcularmos o integGL e o integAn, utilizamos o n = 2, que não é uma aproximação tão boa assim. Para n maiores, já podemos observar um resultado consideravelmente similar:<jupyter_code>w,y = get_w_and_y_5(a, b, 5)
integGL2 = gaussLegendre(y, 5, a, b, w)
print("Diferença para o cálculo exato =", resp_exata-integGL2)<jupyter_output>Diferença para o cálculo exato = 8.247762472990416e-10
{'fraction_non_alphanumeric': 0.16441441441441443, 'fraction_numerical': 0.12105855855855856, 'mean_word_length': 4.286309523809524, 'pattern_counts': {'":': 0, '<': 57, '<?xml version=': 0, '>': 65, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 18, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '16', 'dir': 'jupyter-structured-clean-dedup', 'id': '283857', 'license': 'MIT', 'n_tokens_mistral': 4706, 'n_tokens_neox': 4122, 'n_words': 919, 'path': 'alc/tp1/tp1.ipynb', 'repo_name': 'brenopoggiali/BCC', 'size': '8880'}