UwagaJest to część starego wielomianowego API. Od wersji 1.4 preferowany jest nowy wielomianowy interfejs API zdefiniowany w numpy.polynomial. Podsumowanie różnic można znaleźć w przewodniku po przejściach.
Funkcja numpy.poly1d() pozwala zdefiniować funkcję wielomianową. Ułatwia zatem stosowanie operacji naturalnych na wielomianach.
Jest to klasa wygody, używana do hermetyzacji „operacji naturalnych” na wielomianach, aby te operacje mogły przejąć ich zwyczajowa forma w kodzie.
Składnia: numpy.poly1d(arr, root, var)
Parametry:
arr: [array_like] Współczynniki wielomianu są podane w malejącej kolejności potęg. Jeśli drugi parametr (root) jest ustawiony na True, wówczas wartości tablicy są pierwiastkami równania wielomianowego.root: [bool, opcjonalne] True oznacza pierwiastki wielomianowe. Domyślnie False.
var: zmienna taka jak x, y, z, której potrzebujemy w wielomianu [domyślnie to x].Argumenty:
c: współczynnik wielomianu.
współczynnik: współczynnik wielomianu.
współczynniki: współczynnik wielomianu.
rząd: rząd lub stopień wielomianu.o: Kolejność lub stopień wielomianu.
r: Pierwiastek wielomianu.
Korzenie: Pierwiastek wielomianu.Powrót: wielomian i zastosowana operacja
Numpy poly1d Przykłady
np.poly1d przykład #1
def _break_points(num, den): " ""Wyodrębnij punkty przerwania nad osią rzeczywistą i zyski podane w tych lokalizacjach""" # 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 # nie przejmuj się nieskończonymi punktami break 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 # tylko dodatnie zyski 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 przykład #2
def test_poly1d_math(self): # tutaj używamy kilku prostych współczynników, aby ułatwić obliczenia p = np.poly1d([1, 2, 4]) q = np. poly1d([4., 2, 1]) attach_equal(p/q, (np.poly1d([0.25]), np.poly1d([1.5, 3.75])))) attach_equal(p. liczba całkowita(), np.p oly1d([1/3, 1., 4., 0.])) attach_equal (p. integ (1), np. poly1d ([1/3, 1., 4., 0.])) p = np .poly1d([1., 2, 3]) q = np. poly1d([3., 2, 1]) attach_equal(p * q, np. poly1d([3., 8., 14., 8., 3.])) attach_equal(p + q, np. poly1d([4., 4., 4.])) attach_equal(p - q, np. poly1d([-2., 0., 2.])) attach_equal(p ** 4, np. poly1d([1., 8., 36., 104., 214., 312., 324., 216., 81.])) attach_equal(p(q), np. poly1d([9., 12., 16., 8., 6.])) attach_equal(q(p), np.poly1d([3., 12., 32., 40., 34.])) attach_equal (p.deriv(), np.poly1d([2.,2.])) attach_equal(p.deriv(2), np.poly1d([2.])) attach_equal(np.polydiv(np.poly1d([) 1, 0, -1]), np.poly1d([1, 1])), (np.poly1d([1., -1.]), np.poly1d([0.]))))
np.poly1d przykład #3
def test_poly1d_str_and_repr(self): p = np.poly1d([1., 2, 3]) attach_equal(repr(p), `poly1d([1 ., 2., 3.])`) asercja_equal(str(p), `2` `1 x + 2 x + 3`) q = np. poly1d([3., 2, 1]) asercja_equal(repr( q), `poly1d([3., 2., 1.])`) attach_equal(str(q), ` 2 ` `3 x + 2 x + 1`) r = np. poli1d([1.89999 + 2j, -3j, -5.12345678, 2 + 1j]) attach_equal(str(r), ` 3 2 ` `(1.9 + 2j) x - 3j x - 5.123 x + (2 + 1j)`) attach_equal(str(np .poly1d([-3, -2, -1])), ` 2 ` `-3 x - 2 x - 1`)
np.poly1d, przykład #4
def data_analysis (e_ph, flux, method = "najmniejsza"): if metoda == "najmniejsza": 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(wielomian, m=1) indx = np.argmax(np.abs(pd(x)))) eph_c = x [indx] pd2 = np. polyder (wielomian, m = 2) p2_roots = np. roots (pd2) p2_roots = p2_roots[p2_roots[:].imag == 0] p2_roots = np. real(p2_roots) Eph_fin = znajdź_rootsp( ,eph_c) return Eph_fin, wielomian elif metoda == "nowa metoda": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x))
np .poly1d, przykład #5
def _systopoly1d(sys): """Wyodrębnij polinomaile z licznikiem i mianownikiem dla systemu""" # Zezwól na wprowadzanie danych z przybornika przetwarzania sygnału if (isinstance(sys, scipy.signal. lti)): nump = sys.num denp = s ys.den else: # Konwertuj na funkcję transferu, jeśli to konieczne sys = _convert_to_transfer_function(sys) # Upewnij się, że mamy system SISO, jeśli (sys.inputs > 1 lub sys.outputs > 1): podnieś ControlMIMONotImplemented() # Zacznij od wyodrębnianie licznika i mianownika z obiektu systemowego nump = sys.num[0][0] denp = sys.den[0][0] # Sprawdź, czy num, den są już wielomianami; w przeciwnym razie konwertuj if (not isinstance(nump, poly1d)): nump = poly1d(nump) if (not isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp)
np .poly1d przykład #6
def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Generuje serię punktów na gładkiej krzywej, które przecinają podane punkty numDegrees - stopnie dopasowanego wielomianu — krzywa robi się dziwna, jeśli ta wartość jest zbyt wysoka dla wejścia n — liczba punktów do wyjścia startTime/endTime/n — n punktów zostanie wygenerowanych w równych odstępach między startTime i endTime ``` _numpyCheck( ) x, y = zip(*valueList2d) jeśli startTime to None: startTime = x[0] jeśli endTime to None: endTime = x[-1] polyFunc = np.poly1d(np.polyfit(x, y, numDegrees)) newX = np.linspace(startTime, endTime, n) retList = [(n, polyFunc(n)) dla n w newX] return retList
np.poly1d przykład #7
def fit_y(self, X, Y, x1, x2): len(X) != 0 # jeśli X zawiera tylko jeden punkt, funkcja on otrzyma linię 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 przykład #8
def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=Brak, process_number= -1 ): """Powinno usunąć liniowy bg na podstawie średniej preedge""" 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"]) dla xas w ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg return (xmcd_data, {"xas_bg_poly_co " ".join(map(str, preedge_poly.coeffs))}) np.poly1d przykład #9
def fit_y(self, X, Y, x1, x2): len(X) != 0 # jeśli X zawiera tylko jeden punkt, funkcja otrzyma linię y=Y[0] jeśli 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 przykład #10
def __init__( self, pierwiastki, wagi=Brak, hn=1,0, kn=1,0, wfunc=Brak, limity=Brak, monic=0,eval_func=Brak): np.poly1d.__init__(self, roots, 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`] = limity 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 # Uwaga: eval_func zostanie odrzucone dla siebie arytmetycznego.__dict__[`_eval_func`] = eval_func