numpy.poly1d() em Python

| | | | | | | | | | |
Observação

Isso faz parte da antiga API polinomial. Desde a versão 1.4, a nova API polinomial definida em numpy.polynomial é preferida. Um resumo das diferenças pode ser encontrado no guia de transição.

A função numpy.poly1d() permite definir uma função polinomial. Portanto, torna mais simples usar operações naturais em polinômios.

É uma classe de conveniência, usada para encapsular operações "naturais" em polinômios para que essas operações possam assumir suas forma habitual no código.

Sintaxe: numpy.poly1d(arr, root, var)
Parâmetros:
arr: [array_like] Os coeficientes polinomiais são fornecidos em ordem decrescente de potências. Se o segundo parâmetro (raiz) for definido como Verdadeiro, os valores da matriz serão as raízes da equação polinomial.

root: [bool, optional] True significa raízes polinomiais. O padrão é False.
var: variável como x, y, z que precisamos no polinômio [padrão é x].

Argumentos:
c: Coeficiente polinomial.
coef: Coeficiente polinomial.
coeficientes: coeficiente polinomial.
ordem: Ordem ou grau do polinômio.
o: Ordem ou grau do polinômio.
r: Raiz polinomial.
raízes: Raiz polinomial.

Retorno: polinômio e a operação aplicada


Exemplos Numpy poly1d

np.poly1d exemplo nº 1

def _break_points(num, den): " ""Extrair pontos de quebra sobre o eixo real e ganhos dados esses locais""" # digite: (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 # não se importa com pontos de quebra infinitos 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 # somente ganhos positivos 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): # aqui usamos alguns coeficientes simples para facilitar os 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. inteiro(), 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.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 exemplo #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 exemplo #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_neaest(p2_roots) ,eph_c) return Eph_fin, polynom elif method == "novo método": passe #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x)) 

np .poly1d example #5

def _systopoly1d(sys): """Extrair polinomails de numerador e denominador para um sistema""" # Permitir entradas da caixa de ferramentas de processamento de sinal if (isinstance(sys, scipy.signal. lti)): nump = sys.num denp = s ys.den else: # Converta para uma função de transferência, se necessário sys = _convert_to_transfer_function(sys) # Certifique-se de que temos um sistema SISO if (sys.inputs > 1 ou sys.outputs > 1): raise ControlMIMONotImplemented() # Comece por extraindo o numerador e denominador do objeto do sistema nump = sys.num[0][0] denp = sys.den[0][0] # Verifica se num, den já são polinômios; caso contrário converta if (não isinstance(nump, poly1d)): nump = poly1d(nump) if (not isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp) 

np .poly1d exemplo #6

def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Gera uma série de pontos em uma curva suave que cruza os pontos dados numDegrees - o graus do polinômio ajustado - a curva fica estranha se este valor for muito alto para a entrada n - número de pontos para saída startTime/endTime/n - n pontos serão gerados em intervalos uniformemente espaçados entre startTime e endTime ``` _numpyCheck( ) x, y = zip(*valueList2d) se startTime for None: startTime = x[0] se endTime for None: endTime = x[-1] polyFunc = np.poly1d(np.polyfit(x, y, numDegrees)) newX = np.linspace(startTime, endTime, n) retList = [(n, polyFunc(n)) para n em newX] return retList 

np.poly1d exemplo #7

 def fit_y(self, X, Y, x1, x2): len(X) != 0 # se X incluir apenas um ponto, a função on obterá a linha y=Y[0] se np.sum(X == X[0]) == len(X): return Y[0], Y[0] p = np.poly1d(np.polyfit( X, Y, 1)) retornam p(x1), p(x2) 

np.poly1d exemplo #8

def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=Nenhum, process_number= -1 ): """Deve-se remover um bg linear com base na média do 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"]) para xas em ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg return (xmcd_data, {"xas_bg_poly_coeffs": " ".join(map(str, preedge_poly.coeffs))}) 

np.poly1d exemplo #9

def fit_y(self, X, Y, x1, x2): len(X) != 0 # se X incluir apenas um ponto, a função obterá a linha y=Y[0] se 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 exemplo #10

def __init__( self, raízes, pesos=Nenhum, hn=1.0, kn=1.0, wfunc=Nenhum, limites=Nenhum, monic=0,eval_func=Nenhum): 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`] = limites 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 será descartado na aritmética self.__dict__[`_eval_func`] = eval_func