numpy.poly1d () पायथन में

| | | | | | | | | | | | | | | | | | | | | | | | | | |
नोट

यह पुराने बहुपद API का हिस्सा है। संस्करण 1.4 के बाद से, numpy.polynomial में परिभाषित नए बहुपद API को प्राथमिकता दी जाती है। अंतरों का सारांश ट्रांज़िशन गाइड में पाया जा सकता है।

numpy.poly1d() फ़ंक्शन एक बहुपद फ़ंक्शन को परिभाषित करने की अनुमति देता है। इसलिए यह बहुपदों पर प्राकृतिक संचालन का उपयोग करना आसान बनाता है।

यह एक सुविधा वर्ग है, जिसका उपयोग बहुपदों पर "प्राकृतिक‚" संचालन को समाहित करने के लिए किया जाता है ताकि उक्त संक्रियाएं उनके कोड में प्रथागत रूप।

वाक्यविन्यास: numpy.poly1d(arr, root, var)
पैरामीटर:
< मजबूत>गिरफ्तारी: [array_like] बहुपद गुणांक घातों के घटते क्रम में दिए गए हैं। यदि दूसरा पैरामीटर (रूट) सही पर सेट है तो सरणी मान बहुपद समीकरण की जड़ें हैं।

रूट: [बूल, वैकल्पिक] ट्रू का अर्थ है बहुपद मूल। डिफ़ॉल्ट गलत है। x] है।

तर्क:
c: बहुपद गुणांक।
coef: बहुपद गुणांक।
गुणांक: बहुपद गुणांक।
आदेश: बहुपद का क्रम या अंश।
o: बहुपद का क्रम या अंश।
r: बहुपद मूल।
मूल: बहुपद मूल।

रिटर्न: बहुपद और लागू किया गया ऑपरेशन


Numpy poly1d उदाहरण

np.poly1d example #1

def _break_points(num, den): " ""इन स्थानों को दिए गए वास्तविक अक्ष और लाभ पर ब्रेक पॉइंट निकालें""" # प्रकार: (np.poly1d, np.poly1d) -> (np.array, np.array) dnum = num.deriv(m=1) dden = den.deriv(m=1) polynom = den * dnum - num * dden real_break_pts = polynom.r # अनंत विराम बिंदुओं की परवाह न करें real_break_pts = real_break_pts[num(real_break_pts) != 0] k_break = -den(real_break_pts) ) / num(real_break_pts) idx = k_break >= 0 # केवल सकारात्मक लाभ k_break = k_break[idx] real_break_pts = real_break_pts[idx] अगर लेन (k_break) == 0: k_break = [0] real_break_pts = den.roots वापसी k_break, real_break_pts 

np.poly1d उदाहरण #2

def test_poly1d_math(self): # यहां हम गणना को आसान बनाने के लिए कुछ सरल गुणांक का उपयोग करते हैं p = np.poly1d([1., 2, 4]) q = np.poly1d([4., 2, 1]) assert_equal(p/q, (np.poly1d([0.25]), np.poly1d([1.5, 3.75]))) assert_equal(p. पूर्णांक (), एनपी.पी oly1d([1/3, 1., 4., 0.])) assert_equal(p.integ(1), np.poly1d([1/3, 1., 4., 0.])) p = np .poly1d([1., 2, 3]) q = np.poly1d([3., 2, 1]) assert_equal(p * q, np.poly1d([3., 8., 14., 8., 3.])) assert_equal(p + q, np.poly1d([4., 4., 4.])) assert_equal(p - q, np.poly1d([-2., 0., 2.])) assert_equal(p ** 4, np.poly1d([1., 8., 36., 104, 214., 312., 324., 216., 81.])) assert_equal(p(q), np. poly1d([9., 12., 16., 8., 6.])) assert_equal(q(p), np.poly1d([3., 12., 32., 40., 34.])) assert_equal (p.deriv(), np.poly1d([2., 2.])) assert_equal(p.deriv(2), np.poly1d([2.])) assert_equal(np.polydiv(np.poly1d([ 1, 0, -1]), np.poly1d([1, 1])), (np.poly1d([1., -1.]), np.poly1d([0.]))) 

np.poly1d उदाहरण #3

def test_poly1d_str_and_repr(self): p = np.poly1d([1, 2, 3]) assert_equal(repr(p), `poly1d([1) ., 2., 3.])`) assert_equal(str(p), ` 2 ` `1 x + 2 x + 3`) q = np.poly1d([3., 2, 1]) assert_equal(repr( क्यू), `पॉली1डी([3., 2., 1.])`) assert_equal(str(q), ` 2` `3 x + 2 x + 1`) r = np.poly1d([1.89999 + 2j, -3j, -5.12345678, 2 + 1j]) assert_equal(str(r), ` 3 2 ` `(1.9 + 2j) x - 3j x - 5.123 x + (2 + 1j)`) assert_equal(str(np) .poly1d([-3, -2, -1])), ` 2 ` `-3 x - 2 x - 1`) 

np.poly1d उदाहरण #4

 def data_analysis(e_ph, flux, method="least"): if method == "least": coeffs = np.polyfit(x=e_ph, y=flux, deg=11) बहुपद = np.poly1d(coeffs) x = np.linspace(e_ph[0], e_ph[-1], num=100) pd = np.polyder(polynom, m=1) indx = np.argmax(np.abs(pd(x))) eph_c = x [इंडक्स] pd2 = np.polyder(बहुपद, m=2) p2_roots = np.roots(pd2) p2_roots = p2_roots[p2_roots[:].imag == 0] p2_roots = np.real(p2_roots) Eph_fin = find_nearest(p2_roots) ,eph_c) वापसी Eph_fin, बहुपद elif विधि == "नई विधि": पास #plt.plot(Etotal, Total, "ro") #plt.plot(x, polynom(x)) 

np .poly1d उदाहरण #5

def _systopoly1d(sys): """सिस्टम के लिए अंश और हर बहुपद निकालें""" # सिग्नल प्रोसेसिंग टूलबॉक्स से इनपुट की अनुमति दें यदि (isinstance(sys, scipy.signal. एलटीआई)): nump = sys.num denp = s ys.den और: # ट्रांसफर फ़ंक्शन में कनवर्ट करें, यदि आवश्यक हो sys = _convert_to_transfer_function(sys) # सुनिश्चित करें कि हमारे पास एक SISO सिस्टम है यदि (sys.inputs > 1 या sys.outputs > 1): ControlMIMONotImplemented() # प्रारंभ करें सिस्टम ऑब्जेक्ट से अंश और हर को निकालना nump = sys.num[0][0] denp = sys.den[0][0] # यह देखने के लिए जांचें कि क्या num, den पहले से ही बहुपद हैं; अन्यथा रूपांतरित करें यदि (नहीं isinstance(nump, poly1d)): nump = poly1d(nump) if (नहीं isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp) 

np .poly1d उदाहरण #6

def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` एक चिकने वक्र पर बिंदुओं की एक श्रृंखला उत्पन्न करता है जो दिए गए अंक numDegrees को पार करता है - फिट किए गए बहुपद की डिग्री - वक्र अजीब हो जाता है यदि यह मान इनपुट n के लिए बहुत अधिक है - आउटपुट स्टार्टटाइम/एंडटाइम/एन-एन पॉइंट्स की संख्या स्टार्टटाइम और एंडटाइम के बीच समान अंतराल अंतराल पर उत्पन्न होगी। ) x, y = zip(*valueList2d) अगर स्टार्टटाइम कोई नहीं है: startTime = x[0] अगर एंडटाइम कोई नहीं है: एंडटाइम = x[-1] polyFunc = np.poly1d(np.polyfit(x, y, numDegrees)) newX = np.linspace(startTime, endTime, n) retList = [(n, polyFunc(n)) for n in newX] रिटर्न रिटलिस्ट 

np.poly1d उदाहरण #7

 def fit_y(self, X, Y, X1, x2): len(X) != 0 # यदि X में केवल एक बिंदु शामिल है, तो फ़ंक्शन पर लाइन y=Y[0] मिलेगी यदि np.sum(X == X[0]) == len(X): रिटर्न Y[0], Y[0] p = np.poly1d(np.polyfit( X, Y, 1)) वापसी p(x1), p(x2) 

np.poly1d उदाहरण #8

def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=None, process_number= -1): """पूर्व बढ़त औसत के आधार पर एक रैखिक बीजी को हटाना चाहिए""" preedge_spectrum = get_preedge_spectrum(process_parameters, xmcd_data) preedge_poly = np.poly1d(np.polyfit(preedge_spectrum["Energy"], preedge_spectrum["XAS" ], 1)) xas_bg = preedge_poly(xmcd_data["Energy"]) xas के लिए ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg रिटर्न (xmcd_data, {"xas_bg_poly_coeffs": " ".join(map(str, preedge_poly.coeffs))}) 

np.poly1d उदाहरण #9

def fit_y(self, X, Y, x1, x2): लेन (एक्स)! = 0 # यदि एक्स में केवल एक बिंदु शामिल है, तो फ़ंक्शन को लाइन y=Y[0] मिलेगी यदि np.sum(X == X[0]) == len(X): रिटर्न Y[0 ], Y[0] p = np.poly1d(np.polyfit(X, Y, 1)) रिटर्न p(x1), p(x2) 

np.poly1d उदाहरण #10

<पूर्व>डीईएफ़ __init__( स्वयं, जड़ें, वजन = कोई नहीं, एचएन = 1.0, केएन = 1.0, wfunc = कोई नहीं, सीमा = कोई नहीं, मोनिक = 0, eval_func = कोई नहीं): np.poly1d.__init__ (स्वयं, जड़ें, r = 1) equiv_weights = [ वेट [के] / wfunc (रूट [के]) के लिए रेंज (लेन (रूट्स))] सेल्फ.__dict__ [`वेट्स`] = एनपी.एरे (लिस्ट (ज़िप (रूट्स, वेट, इक्विव_वेट्स))) self. __dict__[`weight_func`] = wfunc self.__dict__[`limits`] = सीमाएं mu = sqrt(hn) अगर मोनिक: evf = eval_func अगर evf: eval_func = लैम्ब्डा x: evf(x)/kn mu = mu / abs( kn) kn = 1.0 self.__dict__[`normcoef`] = mu self.__dict__[`coeffs`] *= kn # नोट: eval_func अंकगणितीय स्वयं पर छोड़ दिया जाएगा।__dict__[`_eval_func`] = eval_func