NumPy 1.14 - numpy.convolve()

numpy.convolve




numpy

numpy.convolve

numpy.convolve(a, v, mode='full') [source]

दो एक आयामी दृश्यों के असतत, रैखिक दृढ़ीकरण लौटाता है।

कनवल्शन ऑपरेटर को अक्सर सिग्नल प्रोसेसिंग में देखा जाता है, जहाँ यह सिग्नल पर रैखिक समय-अपरिवर्तनीय प्रणाली के प्रभाव को [R2626] । संभाव्यता सिद्धांत में, दो स्वतंत्र यादृच्छिक चर का योग उनके व्यक्तिगत वितरण के दृढ़ संकल्प के अनुसार वितरित किया जाता है।

यदि v , a से अधिक a , तो सरणियों को गणना से पहले स्वैप किया जाता है।

पैरामीटर:

a : (N,) array_like

पहला एक आयामी इनपुट सरणी।

v : (एम,) array_like

दूसरा एक आयामी इनपुट सरणी।

मोड : {'पूर्ण', 'वैध', 'समान'}, वैकल्पिक

'पूर्ण':

डिफ़ॉल्ट रूप से, मोड 'पूर्ण' है। यह ओवरलैप के प्रत्येक बिंदु पर (N + M-1,) के आउटपुट आकार के साथ कनवल्शन लौटाता है। दृढ़ संकल्प के अंतिम बिंदुओं पर, संकेत पूरी तरह से ओवरलैप नहीं होते हैं, और सीमा प्रभाव देखा जा सकता है।

'वही':

मोड 'समान' लंबाई max(M, N) का आउटपुट देता है। सीमा प्रभाव अभी भी दिखाई दे रहे हैं।

'वैध':

मोड 'मान्य' लंबाई max(M, N) - min(M, N) + 1 आउटपुट देता है। कनवेंशन उत्पाद केवल उन बिंदुओं के लिए दिया जाता है जहां सिग्नल पूरी तरह से ओवरलैप होते हैं। सिग्नल सीमा के बाहर के मूल्यों का कोई प्रभाव नहीं है।

यह दिखाता है:

बाहर : ndarray

असतत, a और v का रैखिक संकेतन।

यह भी देखें

scipy.signal.fftconvolve
फास्ट फूरियर ट्रांसफॉर्म का उपयोग करके दो सरणियों को समझाना।
scipy.linalg.toeplitz
कंफर्मेशन ऑपरेटर का निर्माण करता था।
polymul
बहुपद गुणन। एक ही आउटपुट के रूप में विकसित, लेकिन यह भी इनपुट के रूप में poly1d वस्तुओं को स्वीकार करता है।

टिप्पणियाँ

असतत सजा ऑपरेशन के रूप में परिभाषित किया गया है

(a * v) [n] = \ sum_ {m = - \ infty} ^ {\ infty} एक [m] v [n - m]

यह दिखाया जा सकता है कि एक दृढ़ संकल्प x (t) * y (t) समय / स्थान गुणन के बराबर है X (f) Y (f) फूरियर डोमेन में, उपयुक्त पैडिंग के बाद (पैडिंग सर्कुलर कन्वेंशन को रोकने के लिए आवश्यक है)। चूंकि गुणा कनवल्शन की तुलना में अधिक कुशल (तेज) है, इसलिए फंक्शन scipy.signal.fftconvolve एफएफटी का उपयोग बड़े डेटा-सेटों के scipy.signal.fftconvolve गणना करने के लिए करता है।

संदर्भ

[R2626] ( 1 , 2 ) विकिपीडिया, "कन्वेंशन", http://en.wikipedia.org/wiki/Convolution

उदाहरण

ध्यान दें कि कैसे कनवल्शन ऑपरेटर ने दूसरे को "स्लाइडिंग" करने से पहले दूसरे सरणी को एक दूसरे के ऊपर फ़्लिप किया:

>>> np.convolve([1, 2, 3], [0, 1, 0.5])
array([ 0. ,  1. ,  2.5,  4. ,  1.5])

केवल कनवल्शन के मध्य मान लौटाएं। सीमा प्रभाव शामिल हैं, जहां शून्य को ध्यान में रखा जाता है:

>>> np.convolve([1,2,3],[0,1,0.5], 'same')
array([ 1. ,  2.5,  4. ])

दो सरणियाँ एक ही लंबाई की हैं, इसलिए केवल एक ही स्थान है जहां वे पूरी तरह से ओवरलैप करते हैं:

>>> np.convolve([1,2,3],[0,1,0.5], 'valid')
array([ 2.5])