Python`da numpy.poly1d ()

| | | | | | | | | | |
Not

Bu, eski polinom API`sinin bir parçasını oluşturur. 1.4 sürümünden bu yana, numpy.polynomial içinde tanımlanan yeni polinom API`si tercih edilir. Farklılıkların bir özeti geçiş kılavuzunda bulunabilir.

numpy.poly1d() işlevi, bir polinom işlevi tanımlamaya izin verir. Bu nedenle, polinomlarda doğal işlemleri kullanmayı kolaylaştırır.

Bu, polinomlar üzerindeki "doğal" işlemleri kapsüllemek için kullanılan bir kolaylık sınıfıdır, böylece söz konusu işlemler kendi görevlerini üstlenebilir. koddaki alışılmış form.

Sözdizimi: numpy.poly1d(arr, root, var)
Parametreler:
< güçlü>dizi: [array_like] Polinom katsayıları azalan güç sırasına göre verilir. İkinci parametre (kök) True olarak ayarlanırsa dizi değerleri polinom denkleminin kökleridir.

root: [bool, isteğe bağlı] True, polinom kökleri anlamına gelir.Varsayılan False`dır.
var: polinomda ihtiyacımız olan x, y, z gibi değişken [varsayılan] x].

Argümanlar:
c: Polinom katsayısı.
katsayı: Polinom katsayısı.
katsayılar: Polinom katsayısı.
sıra: Polinomun derecesi veya derecesi.
o: Polinomun sırası veya derecesi.
r: Polinom kökü.
kökler: Polinom kökü.

Dönüş: Polinom ve uygulanan işlem


Numpy poly1d Örnekler

np.poly1d örnek #1

def _break_points(num, den): " ""Gerçek eksen üzerindeki kırılma noktalarını ve bu konumlarda verilen kazançları ayıkla""" # type: (np.poly1d, np.poly1d) -> (np.array, np.array) dnum = num.deriv(m=1) dden = den.deriv(m=1) polinom = den * dnum - num * dden real_break_pts = polinom.r # sonsuz kırılma noktaları umrumda değil 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 # sadece pozitif kazançlar k_break = k_break[idx] real_break_pts = real_break_pts[idx] if len(k_break) == 0: k_break = [0] real_break_pts = den.breakroots dönüşü k_ real_break_pts 

np.poly1d örnek #2

def test_poly1d_math(self): # burada hesaplamaları kolaylaştırmak için bazı basit katsayılar kullanıyoruz 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. tam(), np.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 örneği #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( q), `poly1d([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 örnek #4

 def data_analysis(e_ph, flux, method="en az"): if method == "en az": katsayılar = np.polyfit(x=e_ph, y=flux, deg=11) polinom = np.poly1d(kats) x = np.linspace(e_ph[0], e_ph[-1], num=100) pd = np.polyder(polinom, m=1) indx = np.argmax(np.abs(pd(x))) eph_c = x [indx] pd2 = np.polyder(polinom, m=2) p2_roots = np.roots(pd2) p2_roots = p2_roots[p2_roots[:].imag == 0] p2_roots = np.real(p2_roots) Eph_fin = find2_roots(pd2) ,eph_c) return Eph_fin, polynom elif method == "new method": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x)) 

np .poly1d örnek #5

def _systopoly1d(sys): """Bir sistem için pay ve payda polinomlarını ayıkla""" # Sinyal işleme araç kutusundan girişlere izin ver if (isinstance(sys, scipy.signal. lti)): nump = sys.num denp = s ys.den başka: # Gerekirse bir aktarım işlevine dönüştürün sys = _convert_to_transfer_function(sys) # Eğer (sys.inputs > 1 veya sys.outputs > 1) bir SISO sistemimiz olduğundan emin olun: ControlMIMONotImplemented() # Başlat pay ve paydanın sistem nesnesinden çıkarılması nump = sys.num[0][0] denp = sys.den[0][0] # num, den`nin zaten polinom olup olmadığını kontrol edin; aksi takdirde if (isinstance(nump, poly1d) değil) dönüştürün: nump = poly1d(nump) if (isinstance(denp, poly1d) değil): denp = poly1d(denp) return (nump, denp) 

np .poly1d örneği #6

def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Düzgün bir eğri üzerinde verilen numDegrees noktalarını geçen bir dizi nokta oluşturur - takılan polinomun dereceleri - bu değer giriş için çok yüksekse eğri tuhaflaşır n - çıkışa giden nokta sayısı startTime/endTime/n - n noktaları, startTime ve endTime arasında eşit aralıklarla oluşturulacak ``` _numpyCheck( ) x, y = zip(*valueList2d) startTime None ise: startTime = x[0] endTime None ise: endTime = x[-1] polyFunc = np.poly1d(np.polyfit(x, y, numDegrees)) newX = np.linspace(startTime, endTime, n) retList = [(n, polyFunc(n)) for newX] return retList 

np.poly1d örnek #7

 def fit_y(self, X, Y, x1, x2): len(X) != 0 # X yalnızca bir nokta içeriyorsa, işlev on, np.sum(X == X[0]) == len(X) ise y=Y[0] satırını alır: Y[0], Y[0] döndür p = np.poly1d(np.polyfit( X, Y, 1)) dönüş p(x1), p(x2) 

np.poly1d örnek #8

def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=Yok, process_number= -1 ): """Ön kenar ortalamasına göre doğrusal bir bg kaldırılmalı""" preedge_spectrum = get_preedge_spectrum(process_parameters, xmcd_data) preedge_poly = np.poly1d( np.polyfit(preedge_spectrum["Energy"], preedge_" ], 1) ) xas_bg = preedge_poly(xmcd_data["Enerji"]) xas için ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg dönüş (xmcd_data, {"xas_bg_poly_coeffs" " ".join(map(str, preedge_poly.coeffs))}) 

np.poly1d örnek #9

def fit_y(self, X, Y, x1, x2): len(X) != 0 # X sadece bir nokta içeriyorsa, fonksiyon y=Y[0] doğrusunu alır, eğer np.sum(X == X[0]) == len(X): Y[0 döndür ], Y[0] p = np.poly1d(np.polyfit(X, Y, 1)) dönüş p(x1), p(x2) 

np.poly1d örnek #10

def __init__( self, kökler, ağırlıklar=Yok, hn=1.0, kn=1.0, wfunc=Yok, limitler=Yok, monic=0,eval_func=Yok): np.poly1d.__init__(self, kökler, r=1) equiv_weights = [ ağırlıklar[k] / wfunc(roots[k]) for k in range(len(roots))] self.__dict__[`weights`] = np.array(list(zip(roots,weights,equiv_weights))) self. __dict__[`weight_func`] = wfunc self.__dict__[`limits`] = limitler mu =  sqrt(hn) monik ise: evf = eval_func eğer evf: eval_func = lambda x: evf(x)/kn mu = mu / abs( kn) kn = 1.0 self.__dict__[`normcoef`] = mu self.__dict__[`coeffs`] *= kn # Not: eval_func, aritmetik self üzerinde atılır.__dict__[`_eval_func`] = eval_func