numpy.poly1d () in Python

| | | | | | | | | | |
Hinweis

Dies ist Teil der alten Polynom-API. Seit Version 1.4 wird die neue Polynom-API, die in numpy.polynomial definiert ist, bevorzugt. Eine Zusammenfassung der Unterschiede finden Sie in der Übergangsanleitung.

Die Funktion numpy.poly1d() ermöglicht es, eine Polynomfunktion zu definieren. Es macht es daher einfach, natürliche Operationen auf Polynome anzuwenden.

Es ist eine bequeme Klasse, die verwendet wird, um "natürliche" Operationen auf Polynome zu kapseln, damit diese Operationen ihre eigenen übernehmen können übliche Form im Code.

Syntax: numpy.poly1d(arr, root, var)
Parameter:
arr: [array_like] Die Polynomkoeffizienten werden in absteigender Reihenfolge der Potenzen angegeben. Wenn der zweite Parameter (root) auf True gesetzt ist, dann sind Array-Werte die Wurzeln der Polynomgleichung.

root: [bool, optional] True bedeutet Polynomwurzeln. Default ist False.
var: Variable wie x, y, z, die wir im Polynom brauchen [default ist x].

Argumente:
c: Polynomialkoeffizient.
coef: Polynomialkoeffizient.
Koeffizienten: Polynomkoeffizient.
Ordnung: Ordnung oder Grad des Polynoms.
o: Ordnung oder Grad des Polynoms.
r: Polynomwurzel.
roots: Polynomwurzel.

Rückgabe: Polynom und die angewandte Operation


Numpy poly1d Beispiele

np.poly1d Beispiel #1

def _break_points(num, den): " ""Unterbrechungspunkte über reale Achse extrahieren und an diesen Stellen gewinnen""" # 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 # sich nicht um unendliche Unterbrechungspunkte kümmern 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 # nur Positive gewinnen 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 example #2

def test_poly1d_math(self): # Hier verwenden wir einige einfache Koeffs, um die Berechnungen zu vereinfachen 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. integ(), 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.ableitung(), np.poly1d([2., 2.])) assert_equal(p.ableitung(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 example #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 Beispiel #4

 def data_analysis(e_ph, flux, method="least"): if method == "least": coeffs = 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(polynom, 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 method == "new method": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x)) 

np .poly1d Beispiel #5

def _systopoly1d(sys): """Zähler- und Nenner-Polynome für ein System extrahieren""" # Eingaben aus der Signalverarbeitungs-Toolbox zulassen, wenn (isinstance(sys, scipy.signal. lti)): nump = sys.num denp = s ys.den else: # Konvertiere in eine Übertragungsfunktion, falls erforderlich sys = _convert_to_transfer_function(sys) # Stelle sicher, dass wir ein SISO-System haben, wenn (sys.inputs > 1 oder sys.outputs > 1): raise ControlMIMONotImplemented() # Beginne mit Extrahieren des Zählers und Nenners aus dem Systemobjekt nump = sys.num[0][0] denp = sys.den[0][0] # Prüfen, ob num, den bereits Polynome sind; andernfalls umwandeln if (not isinstance(nump, poly1d)): nump = poly1d(nump) if (not isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp) 

np .poly1d example #6

def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Erzeugt eine Reihe von Punkten auf einer glatten Kurve, die die gegebenen Punkte numDegrees - the kreuzt Grad des angepassten Polynoms - die Kurve wird seltsam, wenn dieser Wert zu hoch für die Eingabe ist n - Anzahl der Punkte zur Ausgabe startTime/endTime/n - n Punkte werden in gleichmäßigen Abständen zwischen startTime und endTime generiert ``` _numpyCheck( ) x, y = zip(*valueList2d) wenn startTime None ist: startTime = x[0] wenn endTime None ist: 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 example #7

 def fit_y(self, X, Y, x1, x2): len(X) != 0 # wenn X nur einen Punkt enthält, werden die Funkti on wird Zeile y=Y[0] erhalten, wenn np.sum(X == X[0]) == len(X): return Y[0], Y[0] p = np.poly1d(np.polyfit( X, Y, 1)) gib p(x1), p(x2) zurück 

np.poly1d example #8

def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=None, process_number= -1): """Sollte einen linearen bg basierend auf dem Preedge-Durchschnitt entfernen""" 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"]) für 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 example #9

def fit_y(self, X, Y, x1, x2): len(X) != 0 # Wenn X nur einen Punkt enthält, erhält die Funktion die Zeile y=Y[0] if np.sum(X == X[0]) == len(X): return Y[0 ], Y[0] p = np.poly1d(np.polyfit(X, Y, 1)) return p(x1), p(x2) 

np.poly1d example #10

def __init__( self, root, weights=None, hn=1.0, kn=1.0, wfunc=None, limits=None, monic=0,eval_func=None): np.poly1d.__init__(self, root, 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`] = limits mu =  sqrt(hn) if monic: evf = eval_func if evf: eval_func = lambda x: evf(x)/kn mu = mu / abs( kn) kn = 1.0 self.__dict__[`normcoef`] = mu self.__dict__[`coeffs`] *= kn # Hinweis: eval_func wird bei arithmetischem self.__dict__[`_eval_func`] = eval_func 
verworfen