Lista 1

Felipe dos Santos

Julia Ayumi Yamasaki
Wellington de Oliveira

1)
2)

import numpy as np

# Item a ::
A = np.zeros((2,2), dtype = 'float')
# a_mn = (m+2)**n

for m in range(2):
for n in range(2):
A[m,n] = ((m+1) + 2)**(n+1)

# Item b ::
B = np.zeros((3,3), dtype = 'float')
# b_mn = 2*n - 3*m

for m in range(3):
for n in range(3):
B[m,n] = 2*(n+1) - 3*(m+1)

# Item c ::
C = np.zeros((2,2), dtype = 'complex')
# c_mn = m + i*n

for m in range(2):
for n in range(2):
C[m,n] = (m+1) + 1j*(n+1)

determinante_A= np.linalg.det(A)
traco_A = np.trace(A)

determinante_B = np.linalg.det(B)
traco_B = np.trace(B)

determinante_C = np.linalg.det(C)
traco_C = np.trace(C)

# Imprimir resultados
print("Matriz A:")
print(A)
print("Traço de A:", traco_A)
print("Determinante de A:", determinante_A)

# Imprimir resultados
print("Matriz B:")
print(B)
print("Traço de B:", traco_B)
print("Determinante de B:", determinante_B)

# Imprimir resultados
print("Matriz C:")
print(C)
print("Traço de C:", traco_C)
print("Determinante de C:", determinante_C)
3)
4)

def encontrar_autovalores(matriz):
# a) Calcular traço e determinante
traco = np.trace(matriz)
det = np.linalg.det(matriz)

# b) Calcular os autovalores usando a fórmula quadrática

discriminante = traco**2 - 4*det

if discriminante >= 0:
avalor1 = (-traco + np.sqrt(discriminante)) / 2
avalor2 = (-traco - np.sqrt(discriminante)) / 2
else:
# Se o discriminante for negativo, os autovalores são
complexos
avalor1 = complex(-traco / 2, np.sqrt(abs(discriminante))
/ 2)
avalor2 = complex(-traco / 2,
-np.sqrt(abs(discriminante)) / 2)

# c) Imprimir os autovalores
print('A matriz:')
print(matriz)
print('Possui traço:')
print(traco)
print('e determinante:')
print(det)
print('Com autovalores:')
print('λ1 =', avalor1)
print('λ2 =', avalor2)

return traco, det, avalor1, avalor2

# Teste com a matriz A

A = np.array([[1, -1], [1, 1]])
autovalores_encontrados = encontrar_autovalores(A)
5)

def soma_infinitos_termos_PG(a, q):

# Verifica se 0 < q < 1

if 0 < q < 1:

# Calcula a soma dos infinitos termos da PG

S_infinito = a / (1 - q)
return S_infinito
else:
return "A condição 0 < q < 1 não é satisfeita."

# Parâmetros da PG 10, 5, 5/2, ...

a = 10
q = 1/2

# Calcula a soma dos infinitos termos da PG

resultado = soma_infinitos_termos_PG(a, q)

# Exibe o resultado
print(f"{resultado}")
6)

def soma_infinitos_termos_PG(a, q):

# Verifica se 0 < q < 1

if 0 < q < 1:

# Calcula a soma dos infinitos termos da PG

S_infinito = a / (1 - q)
return S_infinito
else:
return "A condição 0 < q < 1 não é satisfeita."

def soma_primeiros_n_termos_PG(a, q, n):

# Calcula a soma dos primeiros n termos da PG
S_n = a * (1 - q**n) / (1 - q)
return S_n

# Parâmetros da PG 10, 5, 5/2, ...

a = 10
q = 1/2

# Valores de n
n_values = [50, 250, 1000]

# Calcula o erro para cada valor de n

for n in n_values:
# Calcula a soma dos infinitos termos da PG
S_infinito = soma_infinitos_termos_PG(a, q)

# Calcula a soma dos primeiros n termos da PG

S_n = soma_primeiros_n_termos_PG(a, q, n)

# Calcula o erro
erro = abs(S_infinito - S_n)

# Exibe os resultados
print(f"\nPara n = {n}:")
print(f"Soma dos infinitos termos da PG: {S_infinito}")
print(f"Soma dos primeiros {n} termos da PG: {S_n}")
print(f"Erro: {erro}")
7)

def soma_infinitos_termos_PG(a, q):

# Verifica se 0 < q < 1
if 0 < q < 1:

# Calcula a soma dos infinitos termos da PG

S_infinito = a / (1 - q)
return S_infinito
else:
return "A condição 0 < q < 1 não é satisfeita."

def numero_termos_necessarios(a, q, E):

# Inicializa o número de termos
n=1

# Calcula a soma dos infinitos termos da PG

S_infinito = soma_infinitos_termos_PG(a, q)

# Calcula a soma dos primeiros n termos da PG

S_n = a * (1 - q**n) / (1 - q)

# Enquanto o erro for maior que E, aumenta o número de termos

while abs(S_infinito - S_n) > E:
n += 1
S_n = a * (1 - q**n) / (1 - q)
return n

# Parâmetros da PG 3, 3/4, 3/8, ...

a=3
q = 1/4

# Valores de E
E_values = [1e-2, 1e-5, 1e-10]

# Calcula o número de termos necessários para cada valor de E

for E in E_values:
n = numero_termos_necessarios(a, q, E)
print(f"\nPara E = {E}:")
print(f"Número de termos necessários: {n}")