Mat/Wrzodak_Koszarek_Zadania.ipynb

Zadanie 4.6

Zadanie 6

Rozwiąż układ równań $Ax=b$ metodą przybliżoną, gdzie

$$A=\left(\begin{array}{rrr} 2 & 4 & 6 \\ 8 & 10 & 12 \\ 14 & 16 & 18 \\ 20 & 22 & 24 \\ 26 & 28 & 31 \end{array}\right)$$

oraz $b=(-1,0,1,0,1)$.

import numpy as np
from sympy import symbols, Matrix, vector
from numpy.linalg import eig

m = np.array([[2, 4, 6],
                [8, 10, 12],
                [14, 16, 18],
                [20, 22, 24],
                [26, 28, 31]])

A=Matrix(m)

np.set_printoptions(formatter={'float_kind':'{:f}'.format})

print('A =')
print(m, '\n')

print('b =')
b=np.array([-1,0,1,0,1])
print(b, '\n')

print('A^T * A =')
print(A.transpose()*A, '\n')
print('Macierz A^T*A jest kwadratowa, więc rozwiązanie istnieje\n')

#print('(A^T * A)^(-1) =')
#print(np.linalg.inv(m.transpose() @ m), '\n')

print('(A^T * A)^(-1)*A.transpose() =')
print(np.linalg.inv(m.transpose() @ m) @ m.transpose(), '\n')

print('Rozwiązanie:\n')
#u=(A.transpose()*A)^(-1)*A.transpose()*b
x = np.linalg.inv(m.transpose() @ m) @ m.transpose() @ b
print('x = (A^T * A)^(-1) * A^T * b =')
print(x, '\n\n')

# SPRAWDZENIE
x, residuals, _, _ = np.linalg.lstsq(m, b, rcond=None)
#print("Przybliżone rozwiązanie:")
#print(x)

A =
[[ 2  4  6]
 [ 8 10 12]
 [14 16 18]
 [20 22 24]
 [26 28 31]] 

b =
[-1  0  1  0  1] 

A^T * A =
Matrix([[1340, 1480, 1646], [1480, 1640, 1828], [1646, 1828, 2041]]) 

Macierz A^T*A jest kwadratowa, więc rozwiązanie istnieje

(A^T * A)^(-1)*A.transpose() =
[[0.050000 -0.233333 -0.516667 -0.800000 1.000000]
 [-0.600000 0.216667 1.033333 1.850000 -2.000000]
 [0.500000 0.000000 -0.500000 -1.000000 1.000000]] 

Rozwiązanie:

x = (A^T * A)^(-1) * A^T * b =
[0.433333 -0.366667 -0.000000] 

Zadanie 4.7

Zadanie 7

Przybliż funkcją $f(t)=a+be^{t}$ zbiór punktów $(1,1)$, $(2,3)$, $(4,5)$ metodą z zadania 6.

import numpy as np
from scipy.optimize import curve_fit

# Definicja funkcji, której chcemy dokonać przybliżenia
def func(t, a, b):
    return a + b * np.exp(t)

# Dane punktów
t_data = np.array([1, 2, 4])
y_data = np.array([1, 3, 5])

# Przybliżanie funkcji do danych punktów
params, _ = curve_fit(func, t_data, y_data)

# Rozwiązania parametrów a i b
a = params[0]
b = params[1]

# Wyświetlenie wyników
print("Przybliżone parametry:")
print("a =", a)
print("b =", b)

Przybliżone parametry:
a = 1.641485981693081
b = 0.06298603382678646

import numpy as np

zb1=np.array([[1,1],[2,3],[4,5]])

m1=np.array([[1,np.exp(1.0)],[1,np.exp(2.0)],[1,np.exp(4.0)]])

#a,b,t=var('a,b,t')

m1*vector([a,b])-vector([1,3,5])

M1=m1.transpose()*m1
M1.det()

M1^(-1)*m1.transpose()*vector([1,3,5])

##########################################################

def func(t, a, b):
    return a + b * np.exp(t)

x = np.linalg.inv(m.transpose() @ m) @ m.transpose() @ b

zbior=[(1,1),(2,3),(4,5)]
print('zbior punktów = ', zbior)
m=matrix(3,2,[1,exp(1.0),1,exp(2.0),1,exp(4.0)])

a,b,t=var('a,b,t')

m*vector([a,b])-vector([1,3,5])

print('\n (m^T * m)^-1 * m^T * vector =')
z = (m.transpose()*m)^(-1)*m.transpose()*vector([1,3,5])
print(z)

plot(z[0] +z[1]*exp(t),(t,0,4))+sum([point(x) for x in zbior])

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[128], line 9
      5 m1=np.array([[1,np.exp(1.0)],[1,np.exp(2.0)],[1,np.exp(4.0)]])
      7 #a,b,t=var('a,b,t')
----> 9 m1*vector([a,b])-vector([1,3,5])
     11 M1=m1.transpose()*m1
     12 M1.det()

TypeError: 'module' object is not callable

Zadanie 4.9

Zadanie 9

Znajdź bazę ortonormalnych wektorów własnych dla macierzy

$$\left(\begin{array}{rrr} 1 & 1 & 0 \\ 1 & 2 & 2 \\ 0 & 2 & 3 \end{array}\right)$$

import numpy as np
from sympy import symbols, Matrix
from numpy.linalg import eig

#Definicja macierzy A
A = np.array([[1,1,0],[1,2,2],[0,2,3]])
#A = Matrix([[1,1,0],[1,2,2],[0,2,3]])
print("Macierz A=")
print(A)

def qr_eigval(matrix, epsilon=1e-10, max_iterations=1000):

    eigenv = np.diag(matrix)

    for _ in range(max_iterations):

        q, r = np.linalg.qr(matrix)
        matrix = np.dot(r, q)
        new_eigenv = np.diag(matrix)

        if np.allclose(eigenv, new_eigenv, atol=epsilon):
            break
        eigenv = new_eigenv

    return eigenv

#Obliczenie wektorów własnych i wartości własnych
#eigenvalues = qr_eigval(matrix)
eigenvalues, eigenvectors = np.linalg.eig(A)

#Dekompozycja
Q, R = np.linalg.qr(eigenvectors)

#Normalizacja wektora własnego
orthonormal_basis = Q

print("Baza ortonormalnych wektorów własnych:")
print(orthonormal_basis)

Macierz A=
[[1 1 0]
 [1 2 2]
 [0 2 3]]
Baza ortonormalnych wektorów własnych:
[[-0.593233 -0.786436 0.172027]
 [0.679313 -0.374362 0.631179]
 [-0.431981 0.491296 0.756320]]

Zadanie 3.9

Zadanie 9

Oblicz metodą ''power iteration'' wartości własne macierzy

$$\left(\begin{array}{rrr} 1 & 2 & 3 \\ 4 & 5 & 6 \\ 7 & 8 & 9 \end{array}\right)$$

import numpy as np

A = np.array([[1,2,3],
              [4,5,6],
              [7,8,9]])

S = np.array([[1,1,1]])

def power_iteration(m, n, s):
    #punkt startowy
    st = s
    eigv = 0
    for i in range(n):
        st = np.dot(A, st)
        eigv = np.max(st)
        st = st/eigv
    return eigv

def power_iteration_vec(m, n, s):
    tolerance = 1e-6
    #punkt startowy
    x = s
    for i in range(n):      
        y = np.dot(m, x)
        #Normalizacja wektora
        x_new = y / np.linalg.norm(y)
        #Sprawdzenie warunku zbieżności
        if np.linalg.norm(x - x_new) < tolerance:
            break
        #Aktualizacja
        x = x_new
    return x

y1 = power_iteration(A, 1000, A)
print("Dominująca wartość własna (power iteration):")
print(y1)

y2 = power_iteration_vec(A, 1000, A)
print("Dominujący wektor własny:")
print(y2)

Dominująca wartość własna (power iteration):
16.116843969807043
Dominujący wektor własny:
[[0.107761 0.132408 0.157054]
 [0.244037 0.299852 0.355666]
 [0.380312 0.467295 0.554278]]

import numpy as np

# Definicja macierzy A
A = np.array([[1,2,3],
              [4,5,6],
              [7,8,9]])
              
# Definicja wektora startowego
x = np.array([1, 1, 1])

# Parametry iteracji
max_iterations = 1000
tolerance = 1e-6

# Iteracyjne obliczanie dominującej wartości własnej i wektora własnego
for _ in range(max_iterations):
    # Mnożenie macierzy przez wektor
    y = np.dot(A, x)

    # Normalizacja wektora
    x_new = y / np.linalg.norm(y)

    # Sprawdzenie warunku zbieżności
    if np.linalg.norm(x - x_new) < tolerance:
        break

    # Aktualizacja wektora
    x = x_new

# Obliczenie dominującej wartości własnej
eigenvalue = np.dot(np.dot(A, x), x) / np.dot(x, x)

# Wyświetlenie wyników
print("Dominująca wartość własna:")
print(eigenvalue)
print("Dominujący wektor własny:")
print(x)

Dominująca wartość własna:
16.116840810027913
Dominujący wektor własny:
[0.231970 0.525322 0.818674]