NotaQuesto fa parte della vecchia API polinomiale. Dalla versione 1.4, è preferita la nuova API polinomiale definita in numpy.polynomial. Un riepilogo delle differenze può essere trovato nella guida alla transizione.
La funzione numpy.poly1d() permette di definire una funzione polinomiale. Semplifica quindi l`uso delle operazioni naturali sui polinomi.
È una classe di convenienza, utilizzata per incapsulare le operazioni "naturali‚" sui polinomi in modo che dette operazioni possano assumere il loro forma consueta nel codice.
Sintassi: numpy.poly1d(arr, root, var)
Parametri:
arr: [array_like] I coefficienti polinomiali sono dati in ordine decrescente di potenze. Se il secondo parametro (radice) è impostato su True, i valori dell`array sono le radici dell`equazione polinomiale.root: [bool, opzionale] True significa radici polinomiali. Il valore predefinito è False.
var: variabile come x, y, z di cui abbiamo bisogno nel polinomio [default è x].Argomenti:
c: Coefficiente polinomiale.
coef: Coefficiente polinomiale.
coefficienti: coefficiente polinomiale.
ordine: ordine o grado del polinomio.o: Ordine o grado del polinomio.
r: Radice del polinomio.
Radici: Radice del polinomio.Return: Polinomio e operazione applicata
Esempi Numpy poly1d
np.poly1d esempio #1
def _break_points(num, den): " ""Estrai punti di interruzione sull`asse reale e guadagni dati queste posizioni""" # 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 # non importa dei punti di interruzione infiniti 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 # guadagni solo positivi 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 esempio #2
def test_poly1d_math(self): # qui usiamo alcuni semplici coefficienti per rendere i calcoli più facili 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.])) 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 esempio #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 esempio #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_nearest(p2_roots ,eph_c) return Eph_fin, polynom metodo elif == "nuovo metodo": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x))
np .poly1d esempio #5
def _systopoly1d(sys): """Estrai i polinomi di numeratore e denominatore per un sistema""" # Consenti input dalla casella degli strumenti di elaborazione del segnale if (isinstance(sys, scipy.signal. lti)): nump = sys.num denp = s ys.den else: # Converti in una funzione di trasferimento, se necessario sys = _convert_to_transfer_function(sys) # Assicurati di avere un sistema SISO se (sys.inputs > 1 o sys.outputs > 1): raise ControlMIMONotImplemented() # Inizia da estraendo numeratore e denominatore dall`oggetto di sistema nump = sys.num[0][0] denp = sys.den[0][0] # Verificare se num, den sono già polinomi; altrimenti converti if (not isinstance(nump, poly1d)): nump = poly1d(nump) if (not isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp)
np .poly1d esempio #6
def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Genera una serie di punti su una curva liscia che attraversa i punti dati numDegrees - il gradi del polinomio adattato - la curva diventa strana se questo valore è troppo alto per l`input n - numero di punti per l`output startTime/endTime/n - verranno generati n punti a intervalli equidistanti tra startTime e endTime ``` _numpyCheck( ) x, y = zip(*valueList2d) se startTime è None: startTime = x[0] se endTime è None: 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 esempio #7
def fit_y(self, X, Y, x1, x2): len(X) != 0 # se X include solo un punto, le funzioni on otterrà la riga 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 esempio #8
def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=Nessuno, process_number= -1 ): """Dovrebbe rimuovere un bg lineare in base alla media 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"]) per xas in ["XAS+", "XAS-", "XAS"]: xmcd_data[xas] -= xas_bg return (xmcd_data, {"xas_bg_poly_coeffs": " ".join(map(str, preedge_poly.coeffs))}) np.poly1d esempio #9
def fit_y(self, X, Y, x1, x2): len(X) != 0 # se X include solo un punto, la funzione otterrà la riga 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 esempio #10
def __init__( self, roots, weights=Nessuno, hn=1.0, kn=1.0, wfunc=Nessuno, limit=Nessuno, monic=0,eval_func=Nessuno): 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`] = limiti 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 verrà scartato in aritmetica self.__dict__[`_eval_func`] = eval_func