NumPy 1.14 - numpy.gradient()

numpy.gradient




numpy

numpy.gradient

numpy.gradient(f, *varargs, **kwargs) [source]

एक एन-आयामी सरणी के ढाल लौटें।

ग्रेडिएंट आंतरिक बिंदुओं में दूसरे क्रम के सटीक केंद्रीय अंतरों का उपयोग करके गणना की जाती है और सीमाओं पर पहले या दूसरे क्रम में सटीक एक-पक्ष (आगे या पीछे) के अंतर का उपयोग किया जाता है। लौटे ग्रेडिएंट में इनपुट सरणी के समान आकार है।

पैरामीटर:

f : array_like

एक एन-आयामी सरणी जिसमें एक स्केलर फ़ंक्शन के नमूने होते हैं।

वैरग : स्केलर या सरणी की सूची, वैकल्पिक

च मानों के बीच अंतर। सभी आयामों के लिए डिफ़ॉल्ट एकात्मक रिक्ति। अंतर का उपयोग करके निर्दिष्ट किया जा सकता है:

  1. सभी आयामों के लिए एक नमूना दूरी निर्दिष्ट करने के लिए एकल स्केलर।
  2. प्रत्येक आयाम के लिए एक निरंतर नमूना दूरी निर्दिष्ट करने के लिए एन स्केलर। यानी dx , dy , dz ,…
  3. एफ के प्रत्येक आयाम के साथ मूल्यों के निर्देशांक को निर्दिष्ट करने के लिए एन सरणियां। सरणी की लंबाई को अधिकतम आयाम के आकार से मेल खाना चाहिए
  4. 2. और 3 के अर्थ के साथ एन स्केलर्स / सरणियों का कोई भी संयोजन।

यदि axis दिया जाता है, तो varargs की संख्या अक्षों की संख्या के बराबर होनी चाहिए। डिफ़ॉल्ट: 1।

edge_order : {1, 2}, वैकल्पिक

सीमाओं पर एन-वें ऑर्डर सटीक अंतर का उपयोग करके ग्रेडिएंट की गणना की जाती है। डिफ़ॉल्ट: 1।

संस्करण 1.9.1 में नया।

अक्ष : कोई भी या int या ints, ints का वैकल्पिक

स्नातक की गणना केवल दिए गए अक्ष या अक्षों के साथ की जाती है। डिफ़ॉल्ट (अक्ष = कोई नहीं) इनपुट सरणी के सभी अक्षों के लिए ढाल की गणना करना है। अक्ष ऋणात्मक हो सकता है, इस स्थिति में यह पिछली से पहली धुरी तक गिना जाता है।

संस्करण 1.11.0 में नया।

यह दिखाता है:

gradient : ndarray या ndarray की सूची

Ndarrays का एक सेट (या यदि केवल एक ही आयाम है तो एक ndarray) प्रत्येक आयाम के संबंध में f के डेरिवेटिव के अनुरूप है। प्रत्येक व्युत्पन्न का आकार च के समान होता है।

टिप्पणियाँ

मानाकि f ^ in C ^ {3} (अर्थात, च कम से कम 3 निरंतर डेरिवेटिव हैं) और होने दो ज _ {*} एक गैर सजातीय कदम, अंतर अंतर गुणांक रिक्ति संगतता त्रुटि को कम करके गणना कर रहे हैं \ Eta_ {मैं} :

\ eta_ {i} = f_ {i} ^ {\ बाएँ (1 \ दाएँ)} - \ बाएँ [\ अल्फा f \ बाएँ (x_ {i} \ दाएँ) + \ बीटा f \ बाएँ (x_ {i} + h_) {d} \ right) + \ gamma f \ left (x_ {i} -h_ {s} \ right) \ right]

प्रतिस्थापन करके f (x_ {i} + h_ {d}) तथा f (x_ {i} - h_ {s}) उनके टेलर श्रृंखला विस्तार के साथ, यह निम्नलिखित रैखिक प्रणाली को हल करने में अनुवाद करता है:

\ बायाँ \ _ \ _ शुरू {सरणी} {r} \ अल्फा + \ बीटा + \ गामा = 0 \\ - \ बीटा h_ {d} + \ Gamma h_ {s} = 1 \\ \ beta h_ {d} ^ {2} + \ Gamma h_ {s} ^ {2} = 0 \ end {व्यू} सही।

के परिणामस्वरूप सन्निकटन F_ {मैं} ^ {(1)} निम्नलखित में से कोई:

\ _ \ _ f_ {i} ^ {(1)} = \ frac {h_ {s} ^ {2} f \ left (x_ {i} + h_ {d} \ right) + \ left (h_ {d} ^ {} 2} - h_ {s} ^ {2} \ right) f \ left (x_ {i} \ right) - h_ {d} ^ {2} f \ left (x_ {i} -h_ {s} \ right) } {h_ {s} h_ {d} \ left (h_ {d} + h_ {s} \ right)} + \ mathcal {O} \ left (\ frac {h_ {d} h_ {s} ^ 2 2} + h_ {s} h_ {d} ^ {2}} {h_ {d} + h_ {s}} \ _}

यह ध्यान देने योग्य है कि यदि h_ {s} = h_ {घ} (यानी, डेटा समान रूप से दूरी पर हैं) हम मानक दूसरे क्रम का अनुमान लगाते हैं:

\ hat f_ {i} ^ {(1)} = \ frac {f \ left (x_ {i + 1} \ right) - f \ left (x_ {i-1} \ right)} {2h} + \ mathcal {हे} \ छोड़ दिया (ज ^ {2} \ right)

इसी तरह की प्रक्रिया के साथ सीमाओं के लिए इस्तेमाल किया जाने वाला आगे / पीछे का अनुमान लगाया जा सकता है।

संदर्भ

[R3638] क्वाटरोनी ए।, सार्को आर।, सालेरी एफ (2007) न्यूमेरिकल मैथमेटिक्स (टेक्सट इन एप्लाइड मैथमेटिक्स)। न्यूयॉर्क: स्प्रिंगर।
[R3738] दुर्रान डीआर (1999) जियोफिजिकल फ्लूइड डायनेमिक्स में वेव समीकरणों के लिए संख्यात्मक तरीके। न्यूयॉर्क: स्प्रिंगर।
[R3838] फोरनबर्ग बी (1988) आर्बिट्ररी स्पेसेड ग्रिड्स पर परिमित अंतर सूत्रों का सृजन, कम्प्यूटेशन 51 का गणित, सं। 184: 699-706। PDF

उदाहरण

>>> f = np.array([1, 2, 4, 7, 11, 16], dtype=float)
>>> np.gradient(f)
array([ 1. ,  1.5,  2.5,  3.5,  4.5,  5. ])
>>> np.gradient(f, 2)
array([ 0.5 ,  0.75,  1.25,  1.75,  2.25,  2.5 ])

रिक्ति को एक सरणी के साथ भी निर्दिष्ट किया जा सकता है जो आयामों के साथ मान F के निर्देशांक का प्रतिनिधित्व करता है। उदाहरण के लिए एक समान रिक्ति:

>>> x = np.arange(f.size)
>>> np.gradient(f, x)
array([ 1. ,  1.5,  2.5,  3.5,  4.5,  5. ])

या एक गैर वर्दी एक:

>>> x = np.array([0., 1., 1.5, 3.5, 4., 6.], dtype=float)
>>> np.gradient(f, x)
array([ 1. ,  3. ,  3.5,  6.7,  6.9,  2.5])

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

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float))
[array([[ 2.,  2., -1.],
        [ 2.,  2., -1.]]), array([[ 1. ,  2.5,  4. ],
        [ 1. ,  1. ,  1. ]])]

इस उदाहरण में रिक्ति को भी निर्दिष्ट किया गया है: अक्ष के लिए वर्दी = 0 और अक्ष के लिए गैर वर्दी = 1

>>> dx = 2.
>>> y = [1., 1.5, 3.5]
>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), dx, y)
[array([[ 1. ,  1. , -0.5],
        [ 1. ,  1. , -0.5]]), array([[ 2. ,  2. ,  2. ],
        [ 2. ,  1.7,  0.5]])]

यह निर्दिष्ट करना संभव है कि किस प्रकार से सीमाओं का इलाज किया जाता है

>>> x = np.array([0, 1, 2, 3, 4])
>>> f = x**2
>>> np.gradient(f, edge_order=1)
array([ 1.,  2.,  4.,  6.,  7.])
>>> np.gradient(f, edge_order=2)
array([-0.,  2.,  4.,  6.,  8.])

axis एक उप-अक्ष निर्दिष्ट करने के लिए उपयोग किया जा सकता है जिसमें ग्रेडिएंट की गणना की जाती है

>>> np.gradient(np.array([[1, 2, 6], [3, 4, 5]], dtype=float), axis=0)
array([[ 2.,  2., -1.],
       [ 2.,  2., -1.]])