सदिश और आव्यूह

सदिश (वेक्टर) संख्याओं की एक साधारण सूची है, जैसे स्थान में दिशा या मात्राओं का समूह। आव्यूह (मैट्रिक्स) पंक्तियों की सूची है। यह पेज अदिश और सदिश गुणनफल, आव्यूह गुणन, सारणिक और प्रतिलोम, कई रैखिक समीकरण एक साथ हल करना और रैखिक बीजगणित की संख्यात्मक विधियाँ समझाता है: आइगेनवैल्यू (अभिलाक्षणिक मान), QR, LU और सिंगुलर वैल्यू अपघटन।

रैखिक बीजगणित की पढ़ाई, ज्यामिति, रूपांतरण या रैखिक समीकरणों से जुड़े कई अज्ञात वाले सवालों में इसका उपयोग करें। सदिश और आव्यूह साधारण सूचियाँ हैं, इसलिए सूचियाँ और सांख्यिकी में दिए इंडेक्स जैसे नियम यहाँ भी लागू हैं।

सदिश

calcकॉपी करें

dot([1, 2, 3], [4, 5, 6]) परिणाम 32

dot([3, 4], [4, -3]) परिणाम 0

cross([1, 0, 0], [0, 1, 0]) परिणाम [0, 0, 1]

cross([1, 2, 3], [4, 5, 6]) परिणाम [-3, 6, -3]

v = [3, 4]

sqrt(dot(v, v)) परिणाम 5

dot समान स्थिति के तत्वों को गुणा करके परिणाम जोड़ता है। अदिश गुणनफल शून्य हो तो सदिश परस्पर लंबवत होते हैं, जैसे [3, 4] और [4, -3]। cross दोनों इनपुट के लंबवत सदिश देता है: x दिशा और y दिशा का सदिश गुणनफल z दिशा है। सदिश की लंबाई उसके अपने साथ अदिश गुणनफल का वर्गमूल है।

dot को समान लंबाई के दो वैक्टर की आवश्यकता होती है, और cross को तीन तत्वों के दो वैक्टर की आवश्यकता होती है। वैक्टर जोड़ने या उन्हें स्केल करने के लिए, साधारण सूची अंकगणित का उपयोग करें: [1, 2] + [3, 4] है [4, 6] और 2 * [3, 4] है [6, 8]।

मैट्रिक्स लिखना और गुणा करना

पंक्तियों की सूची के रूप में एक मैट्रिक्स लिखें, प्रत्येक पंक्ति अपने स्वयं के वर्ग कोष्ठक में:

calcकॉपी करें

shape([[1, 2, 3], [4, 5, 6]]) परिणाम [2, 3]

transpose([[1, 2, 3], [4, 5, 6]]) परिणाम [[1, 4], [2, 5], [3, 6]]

identity(3) परिणाम [[1, 0, 0], [0, 1, 0], [0, 0, 1]]

[[1, 2], [3, 4]] * [[5, 6], [7, 8]] परिणाम [[19, 22], [43, 50]]

shape का उत्तर [rows, columns] है। transpose पंक्तियों और कॉलम को आपस में बदलता है। identity(n) एक n गुणा n का तत्समक आव्यूह है; इससे किसी आव्यूह को गुणा करने पर वही आव्यूह मिलता है।

दो मैट्रिक्स के बीच * मैट्रिक्स गुणन है, जिसके लिए बाएं मैट्रिक्स को उतने ही कॉलम की आवश्यकता होती है जितने दाएं मैट्रिक्स में पंक्तियां होती हैं। एक मैट्रिक्स को वेक्टर से गुणा करने के लिए, वेक्टर को कॉलम के रूप में लिखें, प्रति पंक्ति एक तत्वः

calcकॉपी करें

# Rotate the point (3, 1) by 90° anticlockwise

rotate = [[0, -1], [1, 0]]

rotate * [[3], [1]] परिणाम [[-1], [3]]

rotate * rotate परिणाम [[-1, 0], [0, -1]]

90° के दो बार घूमने से आधा मोड़ आता है, यही कारण है कि rotate * rotate दोनों संकेतों को पलट देता है। एक समतल सूची जैसे [3, 1] मैट्रिक्स के दाईं ओर स्वीकार नहीं की जाती। यदि आपके पास किसी नाम में एक समतल सूची है, तो transpose([v]) इसे एक स्तंभ में बदल देता है।

अन्य सूचियों की तरह, एक ही आकार के मैट्रिक्स को जोड़ा और घटाया जा सकता है, और एक संख्यात्मक मूल्य से गुणा या विभाजित किया जा सकता है।

प्रत्येक मैट्रिक्स ऑपरेशन पर कुछ नियम लागू होते हैंः

• प्रत्येक पंक्ति में समान संख्या में तत्व होने चाहिए।
• तत्व सादे संख्या होने चाहिए। इकाइयों और धन को स्वीकार नहीं किया जाता है।
• एक मैट्रिक्स में अधिकतम 32 पंक्तियां और 32 कॉलम हो सकते हैं।
• सेमीकोलन वाला संक्षिप्त रूप समर्थित नहीं है। [1, 2; 3, 4] के बजाय [[1, 2], [3, 4]] लिखें।

सारणिक, प्रतिलोम, ट्रेस और रैंक

calcकॉपी करें

M = [[2, 1], [5, 3]]

det(M) परिणाम 1

inverse(M) परिणाम [[3, -1], [-5, 2]]

M * inverse(M) परिणाम [[1, 0], [0, 1]]

trace(M) परिणाम 5

inverse([[2, 1], [1, 3]]) परिणाम [[0.6, -0.2], [-0.2, 0.4]]

det([[1, 2], [2, 4]]) परिणाम 0

rank([[1, 2, 3], [2, 4, 6]]) परिणाम 1

det, inverse और trace (मुख्य विकर्ण के तत्वों का योग) के लिए वर्ग आव्यूह चाहिए। सारणिक शून्य हो तो आव्यूह सिंगुलर है: उसकी पंक्तियाँ रैखिक रूप से स्वतंत्र नहीं हैं और उसका प्रतिलोम नहीं है। इसलिए inverse([[1, 2], [2, 4]]) त्रुटि देता है। rank स्वतंत्र पंक्तियों की संख्या बताता है और गैर-वर्ग आव्यूह भी स्वीकार करता है। आखिरी पंक्ति में दूसरी पंक्ति पहली की दोगुनी है, इसलिए रैंक 1 है।

ये चार फ़ंक्शन दशमलव सन्निकटन के बजाय सटीक भिन्न इस्तेमाल करते हैं। इसलिए M * inverse(M) ठीक तत्समक आव्यूह देता है।

रैखिक समीकरणों का निकाय हल करें

मान लीजिए कि तीन कॉफ़ी और दो चाय की क़ीमत £13.50 है, और एक कॉफ़ी और चार चाय की क़ीमत £11.50 है। प्रत्येक पेय की संख्या को प्रति समीकरण एक पंक्ति में रखें, कॉलम को एक निश्चित क्रम (कॉफ़ी, चाय) में रखें, और कुल मिलाकर एक मिलान सूची में रखें:

calcकॉपी करें

solve_system([[3, 2], [1, 4]], [13.5, 11.5]) परिणाम [3.1, 2.1]

उत्तर कॉलम के क्रम में मिलता है: एक कॉफ़ी £3.10 और एक चाय £2.10। मुद्रा संकेत न लिखें, क्योंकि आव्यूह के तत्व बिना इकाई वाली संख्याएँ होने चाहिए।

solve_system(A, b), A * x = b में x का हल निकालता है। इसके लिए वर्ग आव्यूह चाहिए, जिसमें हर अज्ञात के लिए एक पंक्ति हो, और उतनी ही लंबाई की दाएँ पक्षों की साधारण सूची हो। यह सटीक भिन्न इस्तेमाल करता है, इसलिए उत्तर में राउंडिंग त्रुटि नहीं होती।

यदि समीकरण एक ही उत्तर नहीं देते हैं, तो आपको एक त्रुटि मिलती है जिसमें कहा जाता है कि सिस्टम का कोई अद्वितीय समाधान नहीं है। उदाहरण के लिए, solve_system([[1, 2], [2, 4]], [3, 6]) विफल हो जाता है क्योंकि दूसरा समीकरण पहला समीकरण दोगुना है। solve_system केवल सीधी रेखा (रैखिक) समीकरणों को संभालता है; जैसे कि x^2 = 2 जैसे समीकरण के लिए, Summation, equation solving and calculus से solve का उपयोग करें।

आइगेनवैल्यू

calcकॉपी करें

eigenvalues([[2, 1], [1, 2]]) परिणाम [1, 3]

eigenvalues([[4, 1], [2, 3]]) परिणाम [5, 2]

eigenvalues([[0, -1], [1, 0]]) परिणाम [i, -i]

eigenvalues वर्ग आव्यूह से एक साधारण सूची देता है। 90° घूर्णन किसी भी दिशा को अपरिवर्तित नहीं छोड़ता, इसलिए उसके आइगेनवैल्यू सम्मिश्र जोड़ी i और -i हैं; सम्मिश्र संख्याएँ देखें। सूची के क्रम पर निर्भर न रहें।

विघटन: QR, LU और SVD

प्रत्येक अपघटन मैट्रिक्स की एक सूची देता है। भागों को बाहर निकालने के लिए इंडेक्स का उपयोग करें:

calcकॉपी करें

A = [[3, 0], [4, 5]]

parts = qr(A)

q = parts[0] परिणाम [[0.6, -0.8], [0.8, 0.6]]

r = parts[1] परिणाम [[5, 4], [0, 3]]

q * r परिणाम [[3, 0], [4, 5]]

गुणनखंडों को वापस गुणा करने पर A मिलता है, इसलिए अपघटन आसानी से जाँच सकते हैं। बाइनरी फ़्लोटिंग-पॉइंट में लगभग 10⁻¹⁵ जैसी छोटी राउंडिंग त्रुटियाँ बच सकती हैं। Varlig इन्हें सूचियों और आव्यूहों में 0 दिखाता है, लेकिन सहेजे मान में सभी अंक रहते हैं। इसलिए अपघटन के परिणामों को देखकर या अंतर की जाँच करके तुलना करें, == से नहीं।

calcकॉपी करें

lu([[2, 1], [4, 3]]) परिणाम [[[0, 1], [1, 0]], [[1, 0], [0.5, 1]], [[4, 3], [0, -0.5]]]

lu देता है [P, L, U], जहां P किसी भी पंक्ति स्वैप को रिकॉर्ड करता है और P * A बराबर होता है L * U. यहां पंक्तियों को स्वैप किया गया था ताकि बड़ी संख्या, 4, पहले उपयोग की जाए।

calcकॉपी करें

B = [[3, 1], [4, 7]]

f = svd(B)

u = f[0]

s = f[1]

vt = f[2]

u * [[s[0], 0], [0, s[1]]] * vt परिणाम [[3, 1], [4, 7]]

svd([[3, 4]]) परिणाम [[[1]], [5], [[0.6, 0.8]]]

svd का उत्तर [U, s, Vt] है। s सिंगुलर वैल्यू की साधारण सूची है, बड़े से छोटे क्रम में। पाठ्यपुस्तकों में B बराबर है U * diag(s) * Vt के। यहाँ diag फ़ंक्शन नहीं है, इसलिए विकर्ण आव्यूह खुद बनाएँ, जैसे [[s[0], 0], [0, s[1]]]।

गैर-वर्ग आव्यूह के लिए qr और svd संक्षिप्त आकार वाले गुणनखंड लौटाते हैं: 3 गुणा 2 आव्यूह के लिए Q भी 3 गुणा 2 होता है, 3 गुणा 3 नहीं।

क्या सटीक है, और क्या अस्वीकार किया गया है

Varlig के स्वीकार किए हर आव्यूह के लिए जोड़, घटाव, गुणा, किसी संख्या से गुणा, transpose, det और inverse की गणना सटीक भिन्नों में होती है। इनपुट या अगली गणना में जाते समय कोई राउंडिंग नहीं होती। इसलिए आव्यूह को उसके प्रतिलोम से गुणा करने पर ठीक तत्समक आव्यूह मिलता है:

calcकॉपी करें

[[1, 2], [3, 4]] + [[10, 20], [30, 40]] परिणाम [[11, 22], [33, 44]]

[[1, 2], [3, 4]] - [[1, 1], [1, 1]] परिणाम [[0, 1], [2, 3]]

3 * [[1, 2], [3, 4]] परिणाम [[3, 6], [9, 12]]

[[1, 2], [3, 4]] * [[0, 1], [1, 0]] परिणाम [[2, 1], [4, 3]]

det([[1, 2], [3, 4]]) परिणाम -2

inverse([[1, 2], [3, 4]]) परिणाम [[-2, 1], [1.5, -0.5]]

inverse([[1, 2], [3, 4]]) * [[1, 2], [3, 4]] परिणाम [[1, 0], [0, 1]]

उत्तर प्रकट होने से पहले हर शर्त की जांच की जाती है, और संदेश कहता है कि कौन सा विफल रहाः

calcकॉपी करें

det([[1, 2, 3], [4, 5, 6]]) परिणाम Unsupported: Expected a square matrix

inverse([[1, 2], [2, 4]]) परिणाम Unsupported: Singular matrix has no inverse

[[1, 2], [3, 4]] + [[1, 2, 3], [4, 5, 6]] परिणाम Unsupported: List dimensions do not match

[[1, 2, 3], [4, 5, 6]] * [[1, 2], [3, 4]] परिणाम Unsupported: Matrix inner dimensions do not match

आव्यूह के तत्व बिना इकाई वाली संख्याएँ होने चाहिए। किसी तत्व में इकाई, रकम या सम्मिश्र मान हो तो गणना रुक जाती है; उन्हें आगे नहीं ले जाया जाता, क्योंकि आव्यूह की कार्रवाइयाँ उनका स्वरूप सुरक्षित नहीं रख सकतीं:

calcकॉपी करें

det([[1 kg, 2], [3, 4]]) परिणाम Unsupported: Matrix entries must be plain numbers; units, money and complex values are not supported

केवल पंक्तियों की एक सूची को मैट्रिक्स के रूप में पढ़ा जाता है। एक सपाट सूची अपना अर्थ रखती है, इसलिए [1, 2] + [3, 4] अभी भी आइटम‑दर‑आइटम [4, 6] है, और [1, 2] * [3, 4] अभी भी dot की ओर इंगित करने वाली एक त्रुटि है।

एक ही स्थान पर समीकरणों, मैट्रिक्स और आंकड़ों में सटीकता के नियमों के लिए, देखें इंजन क्या गारंटी देता है।

एल्गोरिदम और सीमाएं

det, inverse, rank और solve_system एक संख्यात्मक मूल्य के आकार पर कैलकुलेटर की सीमाओं के भीतर सटीक अंशों के साथ काम करते हैं। eigenvalues, qr, lu और svd बाइनरी फ़्लोटिंग पॉइंट में काम करते हैं, इसलिए उनके उत्तर निकट अनुमान हैं। 10,000 कदमों के बाद उनकी पुनरावृत्तियां रुक जाती हैं।

जिन आव्यूहों की पंक्तियाँ लगभग रैखिक रूप से निर्भर हों, जैसे [[1, 1], [1, 1.0000001]], वे ill-conditioned कहलाते हैं। उनमें छोटी राउंडिंग त्रुटियाँ बहुत बढ़ सकती हैं। इसलिए ऐसे आव्यूहों के अपघटन और आइगेनवैल्यू की सटीकता घट सकती है। अत्यधिक मामलों में संख्यात्मक सीमा पार होने से त्रुटि भी आ सकती है।

पूर्ण नियम उन्नत गणित संदर्भ में हैं।

इसे एक साथ रखना

एक बाज़ार स्टाल से तीन रसीदें बताती हैं कि कितने सेब, केले और संतरे ख़रीदे गए थे और कुल भुगतान किया गया था, लेकिन व्यक्तिगत क़ीमतें नहीं:

calcकॉपी करें

# Each row: apples, bananas, oranges

baskets = [[2, 3, 1], [1, 2, 3], [4, 1, 2]]

paid = [2.15, 2.70, 3.05]

det(baskets) परिणाम 25

prices = solve_system(baskets, paid) परिणाम [0.4, 0.25, 0.6]

# Check the prices against every receipt

baskets * transpose([prices]) परिणाम [[2.15], [2.7], [3.05]]

# What would 5 apples, 2 bananas and 4 oranges cost?

dot([5, 2, 4], prices) परिणाम 4.9

गैर-शून्य सारणिक पुष्टि करता है कि इन रसीदों से कीमतों का एक निश्चित हल निकल सकता है: सेब 40p, केला 25p और संतरा 60p। खरीदारी की मात्राओं को कीमतों के कॉलम से गुणा करने पर वही कुल वापस मिलते हैं। dot से नई खरीदारी का कुल £4.90 निकलता है।