NumPy 1.14 - numpy.polynomial.laguerre.lagint()

numpy.polynomial.laguerre.lagint




numpy

numpy.polynomial.laguerre.lagint

numpy.polynomial.laguerre.lagint(c, m=1, k=[], lbnd=0, scl=1, axis=0) [source]

एक Laguerre श्रृंखला का एकीकरण करें।

axis साथ lbnd से lbnd श्रृंखला गुणांक c एकीकृत m समय देता है। प्रत्येक पुनरावृत्ति पर परिणामी श्रृंखला को scl से गुणा किया जाता है और एक एकीकरण स्थिर, k , जोड़ा जाता है। स्केलिंग कारक परिवर्तनशील के रैखिक परिवर्तन में उपयोग के लिए है। ("क्रेता सावधान रहें": ध्यान दें कि, जो कुछ कर रहा है, उसके आधार पर, कोई भी व्यक्ति जो अपेक्षा कर सकता है, उसके लिए scl को हो सकता है, अधिक जानकारी के लिए, नीचे दिए गए नोट्स अनुभाग देखें।) तर्क c गुणांकों की एक सरणी है। प्रत्येक अक्ष के साथ उच्च डिग्री तक, उदाहरण के लिए, [1,2,3] श्रृंखला L_0 + 2*L_1 + 3*L_2 प्रतिनिधित्व करता है, जबकि [[1,2], [1,2]] 1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) + 2*L_0(x)*L_1(y) + 2*L_1(x)*L_1(y) प्रतिनिधित्व करता है। 1*L_0(x)*L_0(y) + 1*L_1(x)*L_0(y) + 2*L_0(x)*L_1(y) + 2*L_1(x)*L_1(y) यदि अक्ष = 0 x और अक्ष = है 1 y

पैरामीटर:

c : array_like

लैगुएरे श्रृंखला गुणांकों की सरणी। यदि c बहुआयामी है, तो अलग-अलग अक्ष, संबंधित सूचकांक द्वारा दिए गए प्रत्येक अक्ष में डिग्री के साथ विभिन्न चर के अनुरूप है।

एम : इंट, वैकल्पिक

एकीकरण का आदेश, सकारात्मक होना चाहिए। (डिफ़ॉल्ट: 1)

k : {[], सूची, अदिश}, वैकल्पिक

एकीकरण निरंतर (s)। lbnd पर पहले इंटीग्रल का मूल्य सूची में पहला मूल्य है, lbnd पर दूसरे इंटीग्रल का मूल्य दूसरा मूल्य है, आदि यदि k == [] (डिफ़ॉल्ट), सभी स्थिरांक शून्य पर सेट हैं। यदि m == 1 , एक सूची के बजाय एक एकल स्केलर दिया जा सकता है।

lbnd : स्केलर, वैकल्पिक

अभिन्न का निचला भाग। (डिफ़ॉल्ट: 0)

scl : स्केलर, वैकल्पिक

प्रत्येक एकीकरण के बाद परिणाम को scl से जोड़ा जाता है इससे पहले कि एकीकरण को जोड़ा जाए। (डिफ़ॉल्ट: 1)

अक्ष : int, वैकल्पिक

अक्ष जिस पर अभिन्न लिया जाता है। (डिफ़ॉल्ट: 0)।

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

यह दिखाता है:

एस : ndarray

लिगुर्रे श्रृंखला अभिन्न के गुणांक।

जन्म देती है:

ValueError

यदि m < 0 , len(k) > m , np.ndim(lbnd) != 0 , या np.ndim(scl) != 0

यह भी देखें

lagder

टिप्पणियाँ

ध्यान दें कि प्रत्येक एकीकरण का परिणाम scl से गुणा किया जाता है। यह नोट करना क्यों महत्वपूर्ण है? कहते हैं कि एक परिवर्तनशील परिवर्तनशील है u = कुल्हाड़ी + बी x सापेक्ष एक अभिन्न अंग। फिर dx = डु / ए , इसलिए एक के बराबर scl स्थापित करने की आवश्यकता होगी 1 / एक - शायद नहीं जो पहले सोचा होगा।

यह भी ध्यान दें कि, सामान्य रूप से, सी-सीरीज़ को एकीकृत करने के परिणाम को सी-सीरीज़ के आधार पर "रिजेक्टेड" करने की आवश्यकता होती है। इस प्रकार, आम तौर पर, इस फ़ंक्शन का परिणाम "अचिंतनीय," सही है; नीचे उदाहरण अनुभाग देखें।

उदाहरण

>>> from numpy.polynomial.laguerre import lagint
>>> lagint([1,2,3])
array([ 1.,  1.,  1., -3.])
>>> lagint([1,2,3], m=2)
array([ 1.,  0.,  0., -4.,  3.])
>>> lagint([1,2,3], k=1)
array([ 2.,  1.,  1., -3.])
>>> lagint([1,2,3], lbnd=-1)
array([ 11.5,   1. ,   1. ,  -3. ])
>>> lagint([1,2], m=2, k=[1,2], lbnd=-1)
array([ 11.16666667,  -5.        ,  -3.        ,   2.        ])