Python में मैट्रिक्स का मल्टीप्लिकेटिव इनवर्स निकालें

NumPy का numpy.linalg.inv() फंक्शन वर्ग मैट्रिक्स का मल्टीप्लिकेटिव इनवर्स (गुणात्मक प्रतिलोम) निकालता है। यह A⁻¹ लौटाता है जैसे कि A @ A⁻¹ = A⁻¹ @ A = I।

सिंटैक्स

numpy.linalg.inv(a)

a: वर्ग मैट्रिक्स (2D ऐरे), आकार (N, N)।
वापसी: इनवर्स मैट्रिक्स, आकार (N, N)।
एक्सेप्शन: सिंगुलर मैट्रिक्स के लिए LinAlgError।

उदाहरण

import numpy as np
from numpy.linalg import inv

# 2x2 मैट्रिक्स
arr = np.array([[5, 10], [15, 20]])

print("मूल मैट्रिक्स:\n", arr)
print("\nडायमेंशन्स:", arr.ndim)
print("डेटा टाइप:", arr.dtype)
print("आकार:", arr.shape)

# इनवर्स निकालें
inv_arr = np.linalg.inv(arr)
print("\nइनवर्स मैट्रिक्स:\n", inv_arr)

# सत्यापन
print("\nA @ A⁻¹:\n", arr @ inv_arr)
print("A⁻¹ @ A:\n", inv_arr @ arr)

आउटपुट

मूल मैट्रिक्स:
 [[ 5 10]
 [15 20]]
डायमेंशन्स: 2
डेटा टाइप: int64
आकार: (2, 2)
इनवर्स मैट्रिक्स:
 [[-0.4  0.2]
 [ 0.3 -0.1]]
A @ A⁻¹:
 [[1. 0.]
 [0. 1.]]
A⁻¹ @ A:
 [[1. 0.]
 [0. 1.]]

गणना विवरण

मैट्रिक्स A = [[a, b], [c, d]] के लिए:

डिटरमिनेंट: det = ad - bc
इनवर्स: A⁻¹ = (1/det) [[d, -b], [-c, a]]

यहां: det = 5×20 - 10×15 = -50
A⁻¹ = (1/-50) [[20, -10], [-15, 5]] = [[-0.4, 0.2], [0.3, -0.1]]

महत्वपूर्ण विचार

वर्ग मैट्रिक्स आवश्यक: केवल (N, N) मैट्रिक्स के लिए काम करता है।
नॉन-सिंगुलर: डिटरमिनेंट ≠ 0 होना चाहिए।
संख्यात्मक स्थिरता: खराब कंडीशन वाले मैट्रिक्स के लिए pinv या solve बेहतर।
डेटा टाइप: आउटपुट हमेशा फ्लोटिंग पॉइंट होता है।

रैखिक समीकरण हल करने के लिए (सुझाया गया)


# A @ x = b हल करने के लिए inv() का उपयोग न करें
# इसके बजाय solve() उपयोग करें (तेज़, अधिक स्थिर)
A = np.array([[5, 10], [15, 20]], dtype=float)
b = np.array([1, 2])

# खराब तरीका
x_bad = np.linalg.inv(A) @ b

# अच्छा तरीका
x_good = np.linalg.solve(A, b)
print("solve() परिणाम:", x_good)

बैच इनवर्स (एकाधिक मैट्रिक्स)


# 3D ऐरे: (बैच_आकार, M, M)
batch = np.array([
    [[1, 2], [3, 4]],
    [[2, 1], [1, 2]],
    [[4, 3], [3, 4]]
])
inv_batch = np.linalg.inv(batch)  # आकार (3, 2, 2)