numpy.poly1d () en Python

| | | | | | | | | | |
Nota

Esto forma parte de la antigua API polinomial. Desde la versión 1.4, se prefiere la nueva API polinomial definida en numpy.polynomial. Puede encontrar un resumen de las diferencias en la guía de transición.

La función numpy.poly1d() permite definir una función polinomial. Por lo tanto, facilita el uso de operaciones naturales en polinomios.

Es una clase de conveniencia, utilizada para encapsular operaciones "naturales" en polinomios para que dichas operaciones puedan tomar su forma habitual en el código.

Sintaxis: numpy.poly1d(arr, root, var)
Parámetros:
arr: [array_like] Los coeficientes del polinomio se dan en orden decreciente de potencias. Si el segundo parámetro (raíz) se establece en True, los valores de la matriz son las raíces de la ecuación del polinomio.

root: [bool, opcional] True significa raíces polinómicas. El valor predeterminado es False.
var: variable como x, y, z que necesitamos en el polinomio [predeterminado es x].

Argumentos:
c: Coeficiente polinomial.
coef: Coeficiente polinomial.
coeficientes: Coeficiente del polinomio.
orden: Orden o grado del polinomio.
o: Orden o grado del polinomio.
r: Raíz del polinomio.
raíces: Raíz del polinomio.

Retorno: Polinomio y la operación aplicada


Ejemplos de Numpy poly1d

Ejemplo #1 de np.poly1d

def _break_points(num, den): " ""Extraiga los puntos de quiebre sobre el eje real y las ganancias dadas estas ubicaciones""" # escriba: (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 # no importan los infinitos puntos de ruptura 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 # solo ganancias positivas 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 ejemplo #2

def test_poly1d_math(self): # aquí usamos algunos coeficientes simples para facilitar los cálculos 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.])) afirmar_igual(p + q, np.poli1d([4., 4., 4.])) afirmar_igual(p - q, np.poli1d([-2., 0., 2.])) afirmar_igual(p ** 4, np.poly1d([1., 8., 36., 104., 214., 312., 324., 216., 81.])) afirmar_igual(p(q), np. poli1d([9., 12., 16., 8., 6.])) afirmar_igual(q(p), np.poli1d([3., 12., 32., 40., 34.])) afirmar_igual (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 ejemplo #3

def test_poly1d_str_and_repr(self): p = np.poly1d([1., 2, 3]) assert_equal(repr(p), `poly1d([1 ., 2., 3.])`) afirmar_igual(str(p), ` 2 ` `1 x + 2 x + 3`) q = np.poly1d([3., 2, 1]) afirmar_igual(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]) afirmar_igual(str(r), ` 3 2 ` `(1.9 + 2j) x - 3j x - 5.123 x + (2 + 1j)`) afirmar_igual(str(np .poly1d([-3, -2, -1])), ` 2 ` `-3 x - 2 x - 1`) 

np.poly1d ejemplo #4

 def data_analysis(e_ph, flux, method="menos"): if method == "menos": 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(polinomio, 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 == "nuevo método": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x)) 

np .poly1d ejemplo #5

def _systopoly1d(sys): """Extraer polinomios de numerador y denominador para un sistema""" # Permitir entradas desde la caja de herramientas de procesamiento de señales si (isinstance(sys, scipy.signal. lti)): num = sys.num denp = s ys.den else: # Convertir a una función de transferencia, si es necesario sys = _convert_to_transfer_function(sys) # Asegurarnos de que tenemos un sistema SISO si (sys.inputs > 1 o sys.outputs > 1): aumentar ControlMIMONotImplemented() # Comenzar por extrayendo el numerador y el denominador del objeto del sistema nump = sys.num[0][0] denp = sys.den[0][0] # Verifique si num, den ya son polinomios; de lo contrario, convierta if (no es instancia (nump, poly1d)): nump = poly1d (nump) if (not isinstance (denp, poly1d)): denp = poly1d (denp) return (nump, denp) 

np .poly1d ejemplo #6

def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Genera una serie de puntos en una curva suave que cruza los puntos dados numDegrees - el grados del polinomio ajustado - la curva se vuelve rara si este valor es demasiado alto para la entrada n - número de puntos para generar startTime/endTime/n - se generarán n puntos a intervalos uniformemente espaciados entre startTime y endTime ``` _numpyCheck( ) x, y = zip(*valueList2d) si startTime es Ninguno: startTime = x[0] si endTime es Ninguno: 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 ejemplo #7

 def fit_y(self, X, Y, x1, x2): len(X) != 0 # si X solo incluye un punto, la función on obtendrá la línea y=Y[0] si np.sum(X == X[0]) == len(X): return Y[0], Y[0] p = np.poly1d(np.polyfit( X, Y, 1)) devuelve p(x1), p(x2) 

np.poly1d ejemplo #8

def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=Ninguno, process_number= -1 ): """Debería eliminar un bg lineal basado en el promedio previo al borde""" 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"]) for xas en ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg return (xmcd_data, {"xas_bg_poly_coeffs": " ".join(map(str, preedge_poly.coeffs))}) 

np.poly1d ejemplo #9

def fit_y(self, X, Y, x1, x2): len(X) != 0 # si X solo incluye un punto, la función obtendrá la línea 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 ejemplo #10

def __init__( self, raíces, pesos=Ninguno, hn=1.0, kn=1.0, wfunc=Ninguno, límites=Ninguno, monic=0,eval_func=Ninguno): np.poly1d.__init__(self, raíces, r=1) equiv_weights = [ pesos[k] / wfunc(raíces[k]) for k in range(len(raíces))] self.__dict__[`pesos`] = np.array(list(zip(raíces,pesos,equiv_pesos))) self. __dict__[`weight_func`] = wfunc self.__dict__[`limits`] = límites 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 # Nota: eval_func se descartará en aritmética self.__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