NumPy 1.14 - Using the Convenience Classes

सुविधा वर्गों का उपयोग करना




numpy

सुविधा वर्गों का उपयोग करना

बहुपद पैकेज द्वारा प्रदान की जाने वाली सुविधा वर्ग हैं:

नाम प्रदान करता है
बहुपद बिजली की श्रृंखला
Chebyshev चेबीशेव श्रृंखला
लेगेंद्रे लीजेंड्री श्रृंखला
Laguerre एक प्रकार की पक्षी श्रृंखला
हर्मिट हरमीत श्रृंखला
HermiteE हरमीते श्रृंखला

इस संदर्भ में श्रृंखला गुणांक द्वारा संबंधित बहुपद आधार कार्यों के परिमित रूप हैं। उदाहरण के लिए, एक बिजली श्रृंखला की तरह दिखता है

p (x) = 1 + 2x + 3x ^ 2

और गुणांकों है [१, २, ३] । एक ही गुणांक के साथ Chebyshev श्रृंखला जैसा दिखता है

p (x) = 1 T_0 (x) + 2 T_1 (x) + 3 T_2 (x)

और अधिक आम तौर पर

p (x) = \ sum_ {i = 0} ^ n c_i T_i (x)

इस मामले में कहां T_n डिग्री के Chebyshev फ़ंक्शन हैं n , लेकिन बस के रूप में आसानी से किसी भी अन्य वर्गों के आधार कार्य हो सकता है। सभी वर्गों के लिए सम्मेलन यह है कि गुणांक ग [i] डिग्री i के आधार फ़ंक्शन के साथ जाता है।

सभी वर्गों में समान विधियां हैं, और विशेष रूप से वे पायथन संख्यात्मक ऑपरेटरों +, -, *, //,%, Divmod, **, ==, और = को लागू करते हैं। फ्लोटिंग पॉइंट राउंडऑफ़ त्रुटियों के कारण अंतिम दो थोड़ा समस्याग्रस्त हो सकते हैं। अब हम NumPy संस्करण 1.7.0 का उपयोग करते हुए विभिन्न ऑपरेशनों का त्वरित प्रदर्शन देते हैं।

मूल बातें

पहले हमें एक बहुपद वर्ग और एक बहुपद उदाहरण के साथ खेलने की आवश्यकता है। वर्गों को सीधे बहुपद पैकेज से या संबंधित प्रकार के मॉड्यूल से आयात किया जा सकता है। यहां हम पैकेज से आयात करते हैं और पारंपरिक बहुपद वर्ग का उपयोग इसकी परिचितता के कारण करते हैं:

>>> from numpy.polynomial import Polynomial as P
>>> p = P([1,2,3])
>>> p
Polynomial([ 1.,  2.,  3.], domain=[-1,  1], window=[-1,  1])

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

>>> p.coef
array([ 1.,  2.,  3.])
>>> p.domain
array([-1.,  1.])
>>> p.window
array([-1.,  1.])

एक बहुपद छापने से डोमेन और खिड़की के बिना एक छोटा रूप तैयार होता है:

>>> print p
poly([ 1.  2.  3.])

जब हम फिटिंग के लिए आते हैं, तो हम डोमेन और विंडो से निपटेंगे, फिलहाल हम उन्हें अनदेखा करते हैं और मूल बीजगणितीय और अंकगणितीय संचालन के माध्यम से चलाते हैं।

जोड़ और घटाव:

>>> p + p
Polynomial([ 2.,  4.,  6.], domain=[-1,  1], window=[-1,  1])
>>> p - p
Polynomial([ 0.], domain=[-1,  1], window=[-1,  1])

गुणा:

>>> p * p
Polynomial([  1.,   4.,  10.,  12.,   9.], domain=[-1,  1], window=[-1,  1])

पॉवर्स:

>>> p**2
Polynomial([  1.,   4.,  10.,  12.,   9.], domain=[-1,  1], window=[-1,  1])

विभाजन:

मंजिल विभाजन, एक € â // â € ™, बहुपद वर्गों के लिए प्रभाग ऑपरेटर है, इस संबंध में बहुपदों को पूर्णांक की तरह माना जाता है। पायथन संस्करणों के लिए <3.x â € â / â € ™ ऑपरेटर नक्शे एक € â // â € ™ के लिए, जैसा कि यह पायथन के लिए करता है, बाद के संस्करणों के लिए एक € / â € ™ केवल विभाजन द्वारा काम करेगा scalars। कुछ बिंदु पर इसे हटा दिया जाएगा:

>>> p // P([-1, 1])
Polynomial([ 5.,  3.], domain=[-1,  1], window=[-1,  1])

शेष:

>>> p % P([-1, 1])
Polynomial([ 6.], domain=[-1,  1], window=[-1,  1])

Divmod:

>>> quo, rem = divmod(p, P([-1, 1]))
>>> quo
Polynomial([ 5.,  3.], domain=[-1,  1], window=[-1,  1])
>>> rem
Polynomial([ 6.], domain=[-1,  1], window=[-1,  1])

मूल्यांकन:

>>> x = np.arange(5)
>>> p(x)
array([  1.,   6.,  17.,  34.,  57.])
>>> x = np.arange(6).reshape(3,2)
>>> p(x)
array([[  1.,   6.],
       [ 17.,  34.],
       [ 57.,  86.]])

प्रतिस्थापन:

एक्स के लिए एक बहुपद को प्रतिस्थापित करें और परिणाम का विस्तार करें। यहां हम विस्तार के बाद डिग्री 4 के एक नए बहुपद के लिए अग्रणी अपने आप में स्थानापन्न। यदि बहुपद को कार्यों के रूप में माना जाता है, तो यह कार्यों की संरचना है:

>>> p(p)
Polynomial([  6.,  16.,  36.,  36.,  27.], domain=[-1,  1], window=[-1,  1])

जड़ें:

>>> p.roots()
array([-0.33333333-0.47140452j, -0.33333333+0.47140452j])

बहुपद उदाहरणों का स्पष्ट रूप से उपयोग करने के लिए यह हमेशा सुविधाजनक नहीं होता है, इसलिए अंकगणितीय परिचालनों में ट्यूपल्स, सूचियाँ, सरणियाँ और स्केलर स्वचालित रूप से डाले जाते हैं:

>>> p + [1, 2, 3]
Polynomial([ 2.,  4.,  6.], domain=[-1,  1], window=[-1,  1])
>>> [1, 2, 3] * p
Polynomial([  1.,   4.,  10.,  12.,   9.], domain=[-1,  1], window=[-1,  1])
>>> p / 2
Polynomial([ 0.5,  1. ,  1.5], domain=[-1,  1], window=[-1,  1])

डोमेन, विंडो या वर्ग के भिन्न होने वाले बहुपदों को अंकगणित में मिलाया जा सकता है:

>>> from numpy.polynomial import Chebyshev as T
>>> p + P([1], domain=[0,1])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 213, in __add__
TypeError: Domains differ
>>> p + P([1], window=[0,1])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 215, in __add__
TypeError: Windows differ
>>> p + T([1])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 211, in __add__
TypeError: Polynomial types differ

लेकिन प्रतिस्थापन के लिए विभिन्न प्रकारों का उपयोग किया जा सकता है। वास्तव में, यह है कि आपस में बहुपद वर्गों का रूपांतरण प्रकार, डोमेन और विंडो कास्टिंग के लिए कैसे किया जाता है:

>>> p(T([0, 1]))
Chebyshev([ 2.5,  2. ,  1.5], domain=[-1,  1], window=[-1,  1])

जो चेबीशेव रूप में बहुपद p को देता है। यह काम करता है क्योंकि T_1 (x) = x और प्रतिस्थापन एक्स के लिये एक्स मूल बहुपद को नहीं बदलता है। हालाँकि, सभी गुणा और भाग Chebyshev श्रृंखला का उपयोग करके किया जाएगा, इसलिए परिणाम का प्रकार।

गणना

बहुपद उदाहरणों को एकीकृत और विभेदित किया जा सकता है।

>>> from numpy.polynomial import Polynomial as P
>>> p = P([2, 6])
>>> p.integ()
Polynomial([ 0.,  2.,  3.], domain=[-1,  1], window=[-1,  1])
>>> p.integ(2)
Polynomial([ 0.,  0.,  1.,  1.], domain=[-1,  1], window=[-1,  1])

पहला उदाहरण p एक बार एकीकृत करता है, दूसरा उदाहरण इसे दो बार एकीकृत करता है। डिफ़ॉल्ट रूप से, एकीकरण की निचली सीमा और एकीकरण निरंतर 0 हैं, लेकिन दोनों को निर्दिष्ट किया जा सकता है।

>>> p.integ(lbnd=-1)
Polynomial([-1.,  2.,  3.], domain=[-1,  1], window=[-1,  1])
>>> p.integ(lbnd=-1, k=1)
Polynomial([ 0.,  2.,  3.], domain=[-1,  1], window=[-1,  1])

पहले मामले में एकीकरण की निचली सीमा -1 पर सेट है और एकीकरण निरंतर 0. है। दूसरे में एकीकरण का क्रम 1 पर सेट है। विभेदन सरल है क्योंकि एकमात्र विकल्प बहुपद को विभेदित करने की संख्या है।

>>> p = P([1, 2, 3])
>>> p.deriv(1)
Polynomial([ 2.,  6.], domain=[-1,  1], window=[-1,  1])
>>> p.deriv(2)
Polynomial([ 6.], domain=[-1,  1], window=[-1,  1])

अन्य बहुपद कंस्ट्रक्टर

गुणांक निर्दिष्ट करके बहुपद का निर्माण करना एक बहुपद उदाहरण प्राप्त करने का सिर्फ एक तरीका है, वे अपनी जड़ों को निर्दिष्ट करके, अन्य बहुपद प्रकार से रूपांतरण करके, और कम से कम वर्ग फिट द्वारा भी बनाए जा सकते हैं। फिटिंग पर अपने स्वयं के अनुभाग में चर्चा की जाती है, नीचे अन्य तरीकों का प्रदर्शन किया गया है:

>>> from numpy.polynomial import Polynomial as P
>>> from numpy.polynomial import Chebyshev as T
>>> p = P.fromroots([1, 2, 3])
>>> p
Polynomial([ -6.,  11.,  -6.,   1.], domain=[-1,  1], window=[-1,  1])
>>> p.convert(kind=T)
Chebyshev([ -9.  ,  11.75,  -3.  ,   0.25], domain=[-1,  1], window=[-1,  1])

कन्वर्ट विधि डोमेन और विंडो को भी परिवर्तित कर सकती है:

>>> p.convert(kind=T, domain=[0, 1])
Chebyshev([-2.4375 ,  2.96875, -0.5625 ,  0.03125], [ 0.,  1.], [-1.,  1.])
>>> p.convert(kind=P, domain=[0, 1])
Polynomial([-1.875,  2.875, -1.125,  0.125], [ 0.,  1.], [-1.,  1.])

संख्यात्मक संस्करणों में = = 1.7.0 basis और cast क्लास तरीके भी उपलब्ध हैं। कास्ट मेथड कन्वर्ट विधि की तरह काम करता है जबकि बेस मेथड दी गई डिग्री के बहुपद को लौटाता है:

>>> P.basis(3)
Polynomial([ 0.,  0.,  0.,  1.], domain=[-1,  1], window=[-1,  1])
>>> T.cast(p)
Chebyshev([ -9.  ,  11.75,  -3.  ,   0.25], domain=[-1,  1], window=[-1,  1])

प्रकारों के बीच बातचीत उपयोगी हो सकती है, लेकिन यह नियमित उपयोग के लिए अनुशंसित नहीं है । 50 डिग्री के चेबीशेव श्रृंखला से उसी डिग्री के एक बहुपद श्रृंखला में पारित होने में संख्यात्मक परिशुद्धता का नुकसान संख्यात्मक मूल्यांकन के परिणामों को अनिवार्य रूप से यादृच्छिक बना सकता है।

फिटिंग

फिटिंग कारण है कि domain और window विशेषताएँ सुविधा कक्षाओं का हिस्सा हैं। समस्या का वर्णन करने के लिए, डिग्री 5 तक के चेबिशेव पॉलिनॉमिअल्स के मान नीचे दिए गए हैं।

>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> x = np.linspace(-1, 1, 100)
>>> for i in range(6): ax = plt.plot(x, T.basis(i)(x), lw=2, label="$T_%d$"%i)
...
>>> plt.legend(loc="upper left")
<matplotlib.legend.Legend object at 0x3b3ee10>
>>> plt.show()
../_images/routines-polynomials-classes-1.png

श्रेणी -1 <= x <= 1 में वे अच्छे होते हैं, समतुल्य कार्य +/- के बीच पड़े होते हैं। - श्रेणी -2 <= x <= 2 के समान प्लॉट बहुत अलग दिखते हैं:

>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> x = np.linspace(-2, 2, 100)
>>> for i in range(6): ax = plt.plot(x, T.basis(i)(x), lw=2, label="$T_%d$"%i)
...
>>> plt.legend(loc="lower right")
<matplotlib.legend.Legend object at 0x3b3ee10>
>>> plt.show()
../_images/routines-polynomials-classes-2.png

जैसा कि देखा जा सकता है, एक € oodgoodâ € भागों तुच्छता के लिए सिकुड़ गया है। फिटिंग के लिए चेबीशेव पॉलिनॉमिअल्स का उपयोग करने में हम उस क्षेत्र का उपयोग करना चाहते हैं जहां x -1 और 1 के बीच है और यही वह है जो window निर्दिष्ट करती है। हालांकि, यह संभावना नहीं है कि फिट होने वाला डेटा उस अंतराल में अपने सभी डेटा बिंदु हैं, इसलिए हम उस अंतराल को निर्दिष्ट करने के लिए domain का उपयोग करते हैं जहां डेटा बिंदु झूठ बोलते हैं। जब फिट किया जाता है, तो डोमेन को पहले रैखिक परिवर्तन द्वारा खिड़की पर मैप किया जाता है और मैप किए गए डेटा बिंदुओं का उपयोग करके सामान्य रूप से कम से कम वर्ग फिट किया जाता है। फिट की खिड़की और डोमेन लौटे श्रृंखला का हिस्सा हैं और कंप्यूटिंग मूल्यों, डेरिवेटिव्स और इस तरह से स्वचालित रूप से उपयोग किए जाते हैं। यदि वे कॉल में निर्दिष्ट नहीं हैं तो फिटिंग रूटीन डिफ़ॉल्ट विंडो और सभी डेटा बिंदुओं को रखने वाले सबसे छोटे डोमेन का उपयोग करेगा। यह एक शोर साइन वक्र के लिए एक फिट के लिए नीचे सचित्र है।

>>> import numpy as np
>>> import matplotlib.pyplot as plt
>>> from numpy.polynomial import Chebyshev as T
>>> np.random.seed(11)
>>> x = np.linspace(0, 2*np.pi, 20)
>>> y = np.sin(x) + np.random.normal(scale=.1, size=x.shape)
>>> p = T.fit(x, y, 5)
>>> plt.plot(x, y, 'o')
[<matplotlib.lines.Line2D object at 0x2136c10>]
>>> xx, yy = p.linspace()
>>> plt.plot(xx, yy, lw=2)
[<matplotlib.lines.Line2D object at 0x1cf2890>]
>>> p.domain
array([ 0.        ,  6.28318531])
>>> p.window
array([-1.,  1.])
>>> plt.show()
../_images/routines-polynomials-classes-3.png