numpy.poly1d() w Pythonie

| | | | | | | | | | |
Uwaga

Jest 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 

Shop

Learn programming in R: courses

$

Best Python online courses for 2022

$

Best laptop for Fortnite

$

Best laptop for Excel

$

Best laptop for Solidworks

$

Best laptop for Roblox

$

Best computer for crypto mining

$

Best laptop for Sims 4

$

Latest questions

NUMPYNUMPY

psycopg2: insert multiple rows with one query

12 answers

NUMPYNUMPY

How to convert Nonetype to int or string?

12 answers

NUMPYNUMPY

How to specify multiple return types using type-hints

12 answers

NUMPYNUMPY

Javascript Error: IPython is not defined in JupyterLab

12 answers

News


Wiki

Python OpenCV | cv2.putText () method

numpy.arctan2 () in Python

Python | os.path.realpath () method

Python OpenCV | cv2.circle () method

Python OpenCV cv2.cvtColor () method

Python - Move item to the end of the list

time.perf_counter () function in Python

Check if one list is a subset of another in Python

Python os.path.join () method