1.2 Matritsa — Amaliyot
Laboratoriya ishi: NumPy bilan matritsa operatsiyalar va robotika qo'llanilishi
🎯 Maqsad
- NumPy matritsa operatsiyalari
- Aylanish matritsalari
- Tenglamalar sistemasini yechish
- Xos qiymatlar va xos vektorlar
1. Asosiy Matritsa Operatsiyalar
import numpy as np
# Matritsa yaratish
A = np.array([[1, 2, 3],
[4, 5, 6],
[7, 8, 9]])
B = np.array([[9, 8, 7],
[6, 5, 4],
[3, 2, 1]])
print("Matritsa A:")
print(A)
# Qo'shish va ayirish
print("\nA + B:")
print(A + B)
print("\nA - B:")
print(A - B)
# Skalyarga ko'paytirish
print("\n3 * A:")
print(3 * A)
# Matritsa ko'paytirish
print("\nA @ B (matritsa ko'paytirish):")
print(A @ B) # yoki np.dot(A, B)
# Element bo'yicha ko'paytirish
print("\nA * B (element-wise):")
print(A * B)
# Transpozitsiya
print("\nA.T (transpozitsiya):")
print(A.T)
2. Determinant va Teskari Matritsa
import numpy as np
A = np.array([[4, 7],
[2, 6]])
# Determinant
det_A = np.linalg.det(A)
print(f"det(A) = {det_A:.4f}")
# Teskari matritsa
if det_A != 0:
A_inv = np.linalg.inv(A)
print("\nA^(-1):")
print(A_inv)
# Tekshirish
print("\nA @ A^(-1):")
print(np.round(A @ A_inv, 10)) # ≈ I
# 3x3 matritsa
B = np.array([[1, 2, 3],
[0, 1, 4],
[5, 6, 0]])
print(f"\ndet(B) = {np.linalg.det(B):.4f}")
print("\nB^(-1):")
print(np.linalg.inv(B))
3. Chiziqli Tenglamalar Sistemasi
import numpy as np
# Ax = b sistemasini yechish
# 2x + 3y = 7
# x + 2y = 4
A = np.array([[2, 3],
[1, 2]])
b = np.array([7, 4])
# Usul 1: np.linalg.solve (tavsiya etiladi)
x = np.linalg.solve(A, b)
print("Yechim (solve):", x)
# Usul 2: Teskari matritsa
x_inv = np.linalg.inv(A) @ b
print("Yechim (inv):", x_inv)
# Tekshirish
print("Tekshirish A @ x:", A @ x)
# Kattaroq sistema
A3 = np.array([[1, 1, 1],
[2, 1, -1],
[1, -1, 2]])
b3 = np.array([6, 1, 5])
x3 = np.linalg.solve(A3, b3)
print("\n3x3 sistema yechimi:", x3)
4. Xos Qiymatlar va Xos Vektorlar
import numpy as np
A = np.array([[4, 1],
[2, 3]])
# Xos qiymatlar va xos vektorlar
eigenvalues, eigenvectors = np.linalg.eig(A)
print("Xos qiymatlar:", eigenvalues)
print("\nXos vektorlar (ustunlar):")
print(eigenvectors)
# Tekshirish: A @ v = λ * v
for i in range(len(eigenvalues)):
lam = eigenvalues[i]
v = eigenvectors[:, i]
print(f"\nλ_{i+1} = {lam:.4f}")
print(f"v_{i+1} = {v}")
print(f"A @ v = {A @ v}")
print(f"λ * v = {lam * v}")
5. Aylanish Matritsalari (2D)
import numpy as np
import matplotlib.pyplot as plt
def rotation_matrix_2d(theta_deg):
"""2D aylanish matritsasi"""
theta = np.radians(theta_deg)
return np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
def rotate_point(point, theta_deg):
"""Nuqtani aylantirish"""
R = rotation_matrix_2d(theta_deg)
return R @ point
# Misol: uchburchakni aylantirish
triangle = np.array([[0, 1, 0.5],
[0, 0, 0.866]])
angles = [0, 30, 60, 90, 120]
plt.figure(figsize=(10, 10))
for angle in angles:
R = rotation_matrix_2d(angle)
rotated = R @ triangle
plt.fill(rotated[0], rotated[1], alpha=0.3, label=f'{angle}°')
plt.plot(rotated[0], rotated[1], 'o-')
plt.axis('equal')
plt.grid(True)
plt.legend()
plt.title('2D Aylanish')
plt.xlabel('X')
plt.ylabel('Y')
plt.savefig('rotation_2d.png', dpi=150)
plt.show()
6. Aylanish Matritsalari (3D)
import numpy as np
def Rx(theta_deg):
"""X o'qi atrofida aylanish"""
t = np.radians(theta_deg)
return np.array([[1, 0, 0],
[0, np.cos(t), -np.sin(t)],
[0, np.sin(t), np.cos(t)]])
def Ry(theta_deg):
"""Y o'qi atrofida aylanish"""
t = np.radians(theta_deg)
return np.array([[ np.cos(t), 0, np.sin(t)],
[0, 1, 0],
[-np.sin(t), 0, np.cos(t)]])
def Rz(theta_deg):
"""Z o'qi atrofida aylanish"""
t = np.radians(theta_deg)
return np.array([[np.cos(t), -np.sin(t), 0],
[np.sin(t), np.cos(t), 0],
[0, 0, 1]])
# Euler burchaklari (ZYX konvensiya)
def euler_to_rotation(roll, pitch, yaw):
"""Roll-Pitch-Yaw dan aylanish matritsasi"""
return Rz(yaw) @ Ry(pitch) @ Rx(roll)
# Misol: Dron yo'nalishi
roll, pitch, yaw = 10, 5, 30 # gradus
R = euler_to_rotation(roll, pitch, yaw)
print("Aylanish matritsasi:")
print(np.round(R, 4))
# Vektor yo'nalishini o'zgartirish
v = np.array([1, 0, 0]) # Old yo'nalish
v_rotated = R @ v
print(f"\nOld vektor: {v}")
print(f"Aylantirilgan: {np.round(v_rotated, 4)}")
7. Homogen Transformatsiya
import numpy as np
def homogeneous_transform(R, t):
"""4x4 homogen transformatsiya matritsasi"""
T = np.eye(4)
T[:3, :3] = R
T[:3, 3] = t
return T
def apply_transform(T, points):
"""Transformatsiyani nuqtalarga qo'llash"""
# Homogen koordinatalarga o'tish
n = points.shape[1]
points_h = np.vstack([points, np.ones(n)])
# Transformatsiya
transformed_h = T @ points_h
# Oddiy koordinatalarga qaytish
return transformed_h[:3, :]
# Misol: Robot qo'li
# Birinchi bo'g'in: Z atrofida 45° aylanish, (0.5, 0, 0) ga siljish
R1 = Rz(45)
t1 = np.array([0.5, 0, 0])
T1 = homogeneous_transform(R1, t1)
# Ikkinchi bo'g'in: Z atrofida 30° aylanish, (0.3, 0, 0) ga siljish
R2 = Rz(30)
t2 = np.array([0.3, 0, 0])
T2 = homogeneous_transform(R2, t2)
# Umumiy transformatsiya
T_total = T1 @ T2
print("Birinchi transformatsiya T1:")
print(np.round(T1, 4))
print("\nUmumiy transformatsiya T1 @ T2:")
print(np.round(T_total, 4))
# End effector pozitsiyasi
origin = np.array([[0], [0], [0]])
end_effector = apply_transform(T_total, origin)
print(f"\nEnd effector pozitsiyasi: {end_effector.flatten()}")
8. LU va QR Dekompozitsiya
import numpy as np
from scipy import linalg
A = np.array([[2, 1, 1],
[4, 3, 3],
[8, 7, 9]])
# LU dekompozitsiya
P, L, U = linalg.lu(A)
print("LU Dekompozitsiya:")
print("P (permutatsiya):")
print(P)
print("\nL (pastki uchburchak):")
print(np.round(L, 4))
print("\nU (yuqori uchburchak):")
print(np.round(U, 4))
print("\nTekshirish P @ L @ U:")
print(np.round(P @ L @ U, 4))
# QR dekompozitsiya
Q, R = np.linalg.qr(A)
print("\n\nQR Dekompozitsiya:")
print("Q (ortogonal):")
print(np.round(Q, 4))
print("\nR (yuqori uchburchak):")
print(np.round(R, 4))
print("\nTekshirish Q @ R:")
print(np.round(Q @ R, 4))
9. SVD va Pseudoinverse
import numpy as np
# To'rtburchak matritsa
A = np.array([[1, 2],
[3, 4],
[5, 6]])
# SVD
U, S, Vt = np.linalg.svd(A)
print("U:")
print(np.round(U, 4))
print("\nSingular qiymatlar:", np.round(S, 4))
print("\nV^T:")
print(np.round(Vt, 4))
# Pseudoinverse
A_pinv = np.linalg.pinv(A)
print("\nPseudoinverse A^+:")
print(np.round(A_pinv, 4))
# Tekshirish: A @ A^+ @ A ≈ A
print("\nA @ A^+ @ A:")
print(np.round(A @ A_pinv @ A, 4))
# Eng kichik kvadratlar usuli
# Ax ≈ b (overdetermined)
b = np.array([1, 2, 3])
x_lstsq = np.linalg.lstsq(A, b, rcond=None)[0]
print(f"\nEng kichik kvadratlar yechimi: {x_lstsq}")
10. Topshiriq: Robot Kinematikasi
import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
def forward_kinematics_3d(dh_params):
"""
Denavit-Hartenberg parametrlari bilan forward kinematika
dh_params: [(theta, d, a, alpha), ...] - har bir bo'g'in uchun
"""
T = np.eye(4)
positions = [np.array([0, 0, 0])]
for theta, d, a, alpha in dh_params:
# DH transformatsiya matritsasi
ct, st = np.cos(theta), np.sin(theta)
ca, sa = np.cos(alpha), np.sin(alpha)
T_i = np.array([
[ct, -st*ca, st*sa, a*ct],
[st, ct*ca, -ct*sa, a*st],
[0, sa, ca, d],
[0, 0, 0, 1]
])
T = T @ T_i
positions.append(T[:3, 3])
return T, positions
# TODO: 3 bo'g'inli robot qo'lini simulyatsiya qiling
# Bo'g'in uzunliklari: L1=1, L2=0.8, L3=0.5 m
# Burchaklar: θ1=30°, θ2=45°, θ3=-30°
# Sizning kodingiz...
✅ Laboratoriya Tekshirish Ro'yxati
- Matritsa operatsiyalari ishlaydi
- Determinant va teskari matritsa
- Tenglamalar sistemasi yechildi
- Xos qiymatlar topildi
- 2D aylanish vizualizatsiya
- 3D aylanish matritsalari
- Homogen transformatsiya
- Robot kinematikasi topshiriq