numpy.poly1d() in Python

| | | | | | | | | | |
Opmerking

Dit maakt deel uit van de oude polynomiale API. Sinds versie 1.4 heeft de nieuwe polynomiale API die is gedefinieerd in numpy.polynomial de voorkeur. Een samenvatting van de verschillen is te vinden in de overgangsgids.

De functie numpy.poly1d() maakt het mogelijk om een polynoomfunctie te definiëren. Het maakt het daarom eenvoudig om natuurlijke bewerkingen op polynomen te gebruiken.

Het is een gemaksklasse, die wordt gebruikt om "natuurlijke" bewerkingen op veeltermen in te kapselen, zodat genoemde bewerkingen hun gebruikelijke vorm in code.

Syntaxis: numpy.poly1d(arr, root, var)
Parameters:
arr: [array_like] De polynoomcoëfficiënten worden gegeven in afnemende volgorde van machten. Als de tweede parameter (root) is ingesteld op True, zijn arraywaarden de wortels van de polynoomvergelijking.

root: [bool, optioneel] True betekent polynoomwortels. Standaard is False.
var: variabele zoals x, y, z die we nodig hebben in polynoom [default is x].

Argumenten:
c: Polynoomcoëfficiënt.
coef: Polynoomcoëfficiënt.
coëfficiënten: Polynoomcoëfficiënt.
volgorde: Volgorde of graad van polynoom.
o: Volgorde of graad van polynoom.
r: Veeltermwortel.
wortels: Veeltermwortel.

Retour: Polynoom en de toegepaste bewerking


Numpy poly1d Voorbeelden

np.poly1d voorbeeld #1

def _break_points(num, den): " ""Extract breekpunten over de reële as en winsten gegeven deze locaties""" # type: (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 # geef niet om oneindige breekpunten 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 # only positives gains k_break = k_break[idx] real_break_pts = real_break_pts[idx] if len(k_break) == 0: k_break = [0] real_break_pts = den.roots return k_break, real_break_pts 

np.poly1d voorbeeld #2

def test_poly1d_math(self): # hier gebruiken we enkele eenvoudige coëfficiënten om berekeningen gemakkelijker te maken 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. geheel(), 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 voorbeeld #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 voorbeeld #4

 def data_analysis(e_ph, flux, method="minst"): if method == "minst": coëffs = np.polyfit(x=e_ph, y=flux, deg=11) polynom = np.poly1d(coeffs) x = np.linspace(e_ph[0], e_ph[-1], num=100) pd = np.polyder(polynoom, m=1) indx = np.argmax(np.abs(pd(x))) eph_c = x [indx] pd2 = np.polyder(polynom, 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) return Eph_fin, polynom elif methode == "nieuwe methode": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x)) 

np .poly1d voorbeeld #5

def _systopoly1d(sys): """Extract teller en noemer polynomails voor een systeem""" # Sta invoer toe van de signaalverwerkingstoolbox if (isinstance(sys, scipy.signal. lti)): nump = sys.num denp = s ys.den else: # Converteer indien nodig naar een overdrachtsfunctie sys = _convert_to_transfer_function(sys) # Zorg ervoor dat we een SISO-systeem hebben indien (sys.inputs > 1 of sys.outputs > 1): verhoog ControlMIMONotImplemented() # Begin met de teller en noemer uit het systeemobject halen nump = sys.num[0][0] denp = sys.den[0][0] # Controleer of num, den al polynomen zijn; anders converteren als (niet isinstance(nump, poly1d)): nump = poly1d(nump) if (not isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp) 

np .poly1d voorbeeld #6

def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Genereert een reeks punten op een vloeiende curve die de gegeven punten kruisen numDegrees - de graden van de aangepaste polynoom - de curve wordt raar als deze waarde te hoog is voor de invoer n - aantal punten om uit te voeren startTime/endTime/n - n punten worden gegenereerd met gelijkmatig verdeelde intervallen tussen startTime en endTime ``` _numpyCheck( ) x, y = zip(*valueList2d) als startTime Geen is: startTime = x[0] als endTime Geen is: endTime = x[-1] polyFunc = np.poly1d(np.polyfit(x, y, numDegrees)) newX = np.linspace(startTime, endTime, n) retList = [(n, polyFunc(n)) for n in newX] return retList 

np.poly1d voorbeeld #7

 def fit_y(self, X, Y, x1, x2): len(X) != 0 # als X maar één punt bevat, de functi on krijgt regel y=Y[0] if np.sum(X == X[0]) == len(X): return Y[0], Y[0] p = np.poly1d(np.polyfit( X, Y, 1)) retourneer p(x1), p(x2) 

np.poly1d voorbeeld #8

def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=None, process_number= -1 ): """Moet een lineaire bg verwijderen op basis van het preedge-gemiddelde""" 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["Energie"]) voor xas in ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg return (xmcd_data, {"xas_bg_poly_coeffs": " ".join(map(str, preedge_poly.coeffs))}) 

np.poly1d voorbeeld #9

def fit_y(self, X, Y, x1, x2): len(X) != 0 # als X slechts één punt bevat, krijgt de functie lijn y=Y[0] if np.sum(X == X[0]) == len(X): return Y[0 ], Y[0] p = np.poly1d(np.polyfit(X, Y, 1)) retourneer p(x1), p(x2) 

np.poly1d voorbeeld #10

def __init__( zelf, wortels, gewichten=Geen, hn=1,0, kn=1,0, wfunc=Geen, limieten=Geen, monic=0,eval_func=Geen): np.poly1d.__init__(zelf, wortels, r=1) equiv_weights = [ weights[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`] = limieten mu =  sqrt(hn) if monic: evf = eval_func if evf: eval_func = lambda x: evf(x)/kn mu = mu / abs( kn) kn = 1.0 zelf.__dict__[`normcoef`] = mu zelf.__dict__[`coeffs`] *= kn # Opmerking: eval_func wordt weggegooid op rekenkundig zelf.__dict__[`_eval_func`] = eval_func