बेवकूफ रूटीन?

Question

मुझे दिए गए वर्ग मैट्रिक्स के सभी नाबालिगों की गणना करने के लिए numpy का उपयोग करने में दिलचस्पी है। क्या ऐसा करने के लिए सरणी स्लाइसिंग का उपयोग करने का एक हल्का तरीका है? मैं कल्पना कर रहा हूं कि कोई कॉलम घुमा सकता है, अंतिम कॉलम हटा सकता है, परिणामस्वरूप मैट्रिक्स की पंक्तियों को घुमाता है और आखिरी पंक्ति को हटा सकता है, लेकिन मुझे numpy दस्तावेज में कुछ भी नहीं मिला है जो इंगित करता है कि यह संभव है।

(प्रश्न: यह क्यों करें? ए: मेरे पास काफी बड़े मैट्रिस का लंबा अनुक्रम {एम_एन} है, लगभग 1,000,000 10,000 x 10,000 मैट्रिक्स, और मैं प्रत्येक मैट्रिक्स के निर्धारक की गणना करना चाहता हूं। प्रत्येक मैट्रिक्स इसके द्वारा प्राप्त किया जाता है केवल एक गुणांक को बदलकर पूर्ववर्ती। अनुक्रम में पहले मैट्रिक्स के निर्धारक की गणना करने के लिए यह बहुत तेज़ होगा, और फिर अंतर det (M_ {n + 1}) - det (M_n) की गणना करें, जो कि है । बदली हुई गुणांक और उसके नाबालिग के उत्पाद)

Answer 1

In [34]: arr=np.random.random((4,4)) 

In [35]: arr 
Out[35]: 
array([[ 0.00750932, 0.47917318, 0.39813503, 0.11755234], 
     [ 0.30330724, 0.67527229, 0.71626247, 0.22526589], 
     [ 0.5821906 , 0.2060713 , 0.50149411, 0.0328739 ], 
     [ 0.42066294, 0.88529916, 0.09179092, 0.39389844]]) 

यह arr की मामूली देता है, 1 पंक्ति और 2 कॉलम को हटा दिया साथ:

In [36]: arr[np.array([0,2,3])[:,np.newaxis],np.array([0,1,3])] 
Out[36]: 
array([[ 0.00750932, 0.47917318, 0.11755234], 
     [ 0.5821906 , 0.2060713 , 0.0328739 ], 
     [ 0.42066294, 0.88529916, 0.39389844]]) 

तो, आप कुछ इस तरह इस्तेमाल कर सकते हैं:

def minor(arr,i,j): 
    # ith row, jth column removed 
    return arr[np.array(range(i)+range(i+1,arr.shape[0]))[:,np.newaxis], 
       np.array(range(j)+range(j+1,arr.shape[1]))] 

---

के बारे में यह कैसे काम करता है:

सूचना सूचकांक सरणियों के आकार:

In [37]: np.array([0,2,3])[:,np.newaxis].shape 
Out[37]: (3, 1) 

In [38]: np.array([0,1,3]).shape 
Out[38]: (3,) 

के उपयोग [:,np.newaxis] केवल पहली सरणी आकार (3,1) देने के लिए था।

चूंकि ये numpy arrays (कहने के बजाय, स्लाइस) हैं, numpy तथाकथित "फैंसी" अनुक्रमण का उपयोग करता है। फैंसी इंडेक्सिंग के नियमों के लिए दो एरे के आकार की आवश्यकता होती है, या, जब वे समान नहीं होते हैं, तो प्रसारण को "पंप-अप" करने के लिए आकार का उपयोग करने के लिए ताकि वे मिलान कर सकें।

इस मामले में, दूसरी सरणी का आकार (3,) (1,3) तक पंप हो गया है। लेकिन (3,1) और (1,3) मेल नहीं खाते हैं, इसलिए (3,1) तक पंप किया गया है (3,3) और (1,3) (3,3) तक पंप किया गया है।

आह, अंत में, दो numpy arrays (प्रसारण के बाद) एक ही आकार, (3,3) है।

न्यूम्पी arr[<array of shape (3,3)>, <array of shape (3,3)>] लेता है और आकार की एक सरणी (आश्चर्यजनक रूप से नहीं) (3,3) देता है।

(i, j) लौटे सरणी के मई के तत्व

arr[(i,j)-th element of first array, (i,j)-th element of second array] 

जहां पहले और दूसरे सरणियों (धारणात्मक) देखने के लिए इस तरह होगा:

first array:  second array: 
[[0 0 0],  [[0, 1, 3], 
[2 2 2],   [0, 1, 3], 
[3 3 3]]   [0, 1, 3]] 

Answer 2

यदि आप केवल एक समय में मैट्रिक्स के एक तत्व को बदलना, आप शायद शेरमेन-मॉरिसन प्रकार सूत्रों का उपयोग करना बेहतर कर सकते हैं, (wiki): इस तरह, आपके पास N^3 की बजाय N^2 की जटिलता है।