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