NumPy 1.14 - numpy.linalg.qr()

numpy.linalg.qr




numpy

numpy.linalg.qr

numpy.linalg.qr(a, mode='reduced') [source]

एक मैट्रिक्स के qr कारक की गणना करें।

मैट्रिक्स को q रूप में फैक्टर करें, जहां q ऑर्थोनॉमिक है और r ऊपरी-त्रिकोणीय है।

पैरामीटर:

a : array_like, आकार (M, N)

फैक्टर होने के लिए मैट्रिक्स।

मोड : {'कम', 'पूर्ण', 'आर', 'कच्चा', 'पूर्ण', 'आर्थिक'}, वैकल्पिक

यदि के = मिनट (एम, एन), तो

  • 'कम': रिटर्न q, r आयामों के साथ (M, K), (K, N) (डिफ़ॉल्ट)
  • 'पूरा': रिटर्न q, r विथ डायमेंशन (M, M), (M, N)
  • 'आर': रिटर्न आर केवल आयाम (के, एन) के साथ
  • 'रॉ': रिटर्न h, ताऊ विथ डाइमेंशन्स (N, M), (K,)
  • 'पूर्ण': 'कम' का उपनाम, पदावनत
  • 'आर्थिक': 'कच्चे' से एच रिटर्न, पदावनत।

विकल्प 'कम', 'पूर्ण' और 'कच्चे' 1.8 में नए हैं, अधिक जानकारी के लिए नोट देखें। डिफ़ॉल्ट 'कम' है, और सुन्न के पुराने संस्करणों के साथ पिछड़े संगतता को बनाए रखने के लिए इसे और पुराने डिफ़ॉल्ट 'पूर्ण' को छोड़ दिया जा सकता है। ध्यान दें कि 'कच्चे' मोड में लौटे सरणी h को फोरट्रान को कॉल करने के लिए स्थानांतरित किया गया है। 'आर्थिक' मोड को हटा दिया गया है। 'पूर्ण' और 'आर्थिक' मोड को पीछे की संगतता के लिए केवल पहले अक्षर का उपयोग करके पारित किया जा सकता है, लेकिन अन्य सभी को वर्तनी से बाहर किया जाना चाहिए। अधिक स्पष्टीकरण के लिए नोट्स देखें।

यह दिखाता है:

q : फ्लोट या जटिल, वैकल्पिक का ndarray

ऑर्थोनॉमिक कॉलम के साथ एक मैट्रिक्स। जब मोड = 'पूरा' होता है, तो परिणाम एक ऑर्थोगोनल / एकात्मक मैट्रिक्स होता है जो इस बात पर निर्भर करता है कि वह वास्तविक / जटिल है या नहीं। उस मामले में निर्धारक या तो +/- 1 हो सकता है।

आर : फ्लोट या जटिल, वैकल्पिक के ndarray

ऊपरी-त्रिकोणीय मैट्रिक्स।

(h, tau) : nd.double या np.cdouble, वैकल्पिक के ndarrays

सरणी h में हाउसहोल्डर रिफ्लेक्टर होते हैं जो r के साथ q उत्पन्न करते हैं। ताऊ सरणी में रिफ्लेक्टर के लिए स्केलिंग कारक होते हैं। पदावनत 'आर्थिक' मोड में केवल एच वापस आ गया है।

जन्म देती है:

LinAlgError

अगर फैक्टरिंग फेल है।

टिप्पणियाँ

यह LAPACK रूटीन dgeqrf, zgeqrf, dorgqr और zungrr के लिए एक इंटरफ़ेस है।

Qr कारक के बारे में अधिक जानकारी के लिए, उदाहरण के लिए देखें: http://en.wikipedia.org/wiki/QR_factorization

Ndarray के उपवर्गों को 'कच्चे' मोड के अलावा संरक्षित किया जाता है। इसलिए यदि a प्रकार matrix , तो सभी रिटर्न मान भी मैट्रिस होंगे।

न्यूम में 'कम', 'पूरा', और मोड के लिए 'रॉ' विकल्पों को 1.8.0 में जोड़ा गया था और पुराने विकल्प 'फुल' को 'कम' का उपनाम बनाया गया था। इसके अलावा विकल्पों 'पूर्ण' और 'आर्थिक' को हटा दिया गया था। क्योंकि 'फुल' पिछला डिफॉल्ट था और 'कम' नया डिफॉल्ट है, mode डिफॉल्ट को डिसेबल करके बैकवर्ड कम्पैटिबिलिटी को बनाए रखा जा सकता है। 'रॉ' विकल्प को इसलिए जोड़ा गया था ताकि LAPACK रूटीन जो हाउसहोल्डर रिफ्लेक्टर का उपयोग करके q से कई गुना बढ़ सके, का उपयोग किया जा सके। ध्यान दें कि इस स्थिति में दिए गए सरणियाँ np.double या np.cdouble प्रकार की हैं और h सरणी को FORTRAN के संगत होने के लिए ट्रांसपोज़ किया गया है। वर्तमान में 'रॉ' रिटर्न का उपयोग करने वाली कोई भी रूटीन खस्ता हालत से उजागर नहीं होती है, लेकिन कुछ लैपैक_लाइट में उपलब्ध हैं और बस आवश्यक कार्य का इंतजार कर रही हैं।

उदाहरण

>>> a = np.random.randn(9, 6)
>>> q, r = np.linalg.qr(a)
>>> np.allclose(a, np.dot(q, r))  # a does equal qr
True
>>> r2 = np.linalg.qr(a, mode='r')
>>> r3 = np.linalg.qr(a, mode='economic')
>>> np.allclose(r, r2)  # mode='r' returns the same r as mode='full'
True
>>> # But only triu parts are guaranteed equal when mode='economic'
>>> np.allclose(r, np.triu(r3[:6,:6], k=0))
True

उदाहरण qr एक सामान्य उपयोग को दर्शाता है: कम से कम वर्गों की समस्याओं को हल करना

निम्नलिखित डेटा के लिए y = y0 + mx में सबसे कम वर्ग-सर्वश्रेष्ठ m और y0 क्या हैं: {(0,1), (1,0), (1,2), (2,1)}। (बिंदुओं को ग्राफ़ करें और आप देखेंगे कि यह y0 = 0, m = 1. होना चाहिए।) इसका उत्तर ओवर-निर्धारित मैट्रिक्स समीकरण Ax = b , जहाँ हल करके दिया गया है:

A = array([[0, 1], [1, 1], [1, 1], [2, 1]])
x = array([[y0], [m]])
b = array([[1], [0], [2], [1]])

यदि A = qr ऐसा है कि q ऑर्थोनॉर्मल है (जो ग्राम-श्मिट के माध्यम से हमेशा संभव है), तो x = inv(r) * (qT) * b । (खसखस में, हालांकि, हम बस lstsq उपयोग करते हैं।)

>>> A = np.array([[0, 1], [1, 1], [1, 1], [2, 1]])
>>> A
array([[0, 1],
       [1, 1],
       [1, 1],
       [2, 1]])
>>> b = np.array([1, 0, 2, 1])
>>> q, r = LA.qr(A)
>>> p = np.dot(q.T, b)
>>> np.dot(LA.inv(r), p)
array([  1.1e-16,   1.0e+00])