RemarqueCela fait partie de l`ancienne API polynomiale. Depuis la version 1.4, la nouvelle API polynomiale définie dans numpy.polynomial est préférée. Un résumé des différences se trouve dans le guide de transition.
La fonction numpy.poly1d() permet de définir une fonction polynomiale. Il est donc simple d`utiliser des opérations naturelles sur des polynômes.
Il s`agit d`une classe de commodité, utilisée pour encapsuler des opérations "naturelles" sur des polynômes afin que lesdites opérations puissent prendre leur forme usuelle dans le code.
Syntaxe : numpy.poly1d(arr, root, var)
Paramètres :
arr : [array_like] Les coefficients polynomiaux sont donnés par ordre décroissant de puissance. Si le deuxième paramètre (racine) est défini sur True, les valeurs du tableau sont les racines de l`équation polynomiale.root : [bool, facultatif] True signifie des racines polynomiales. La valeur par défaut est False.
var : variable comme x, y, z dont nous avons besoin dans le polynôme [default est x].Arguments :
c : Coefficient polynomial.
coef : Coefficient polynomial.
coefficients : coefficient polynomial.
ordre : ordre ou degré du polynôme.o : ordre ou degré du polynôme.
r : racine du polynôme.
racines : racine du polynôme.Retour : polynôme et l`opération appliquée
Exemples poly1d numpy
exemple np.poly1d #1
def _break_points(num, den): " ""Extraire les points de rupture sur l`axe réel et les gains en fonction de ces emplacements""" # tapez : (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 # ne vous souciez pas des points de rupture infinis 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 # seuls les gains positifs 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) : # ici, nous utilisons quelques coefficients simples pour faciliter les calculs 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 example #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 example #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(polynome, 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 == "new method": pass #plt.plot(Etotal, total, "ro") #plt.plot(x, polynom(x))
np .poly1d example #5
def _systopoly1d(sys): """Extraire les polynoms du numérateur et du dénominateur pour un système""" # Autoriser les entrées de la boîte à outils de traitement du signal if (isinstance(sys, scipy.signal. lti)): num = sys.num denp = s ys.den else : # Convertir en une fonction de transfert, si nécessaire sys = _convert_to_transfer_function(sys) # Assurez-vous que nous avons un système SISO si (sys.inputs > 1 ou sys.outputs > 1) : raise ControlMIMONotImplemented() # Commencer par extraction du numérateur et du dénominateur de l`objet système nump = sys.num[0][0] denp = sys.den[0][0] # Vérifiez si num, den sont déjà des polynômes ; sinon convertir if (not isinstance(nump, poly1d)): nump = poly1d(nump) if (not isinstance(denp, poly1d)): denp = poly1d(denp) return (nump, denp)
np .poly1d example #6
def quadraticInterpolation(valueList2d, numDegrees, n, startTime=None, endTime=None): ``` Génère une série de points sur une courbe lisse qui croise les points donnés numDegrees - le degrés du polynôme ajusté - la courbe devient bizarre si cette valeur est trop élevée pour l`entrée n - nombre de points à sortir startTime/endTime/n - n points seront générés à intervalles réguliers entre startTime et endTime ``` _numpyCheck( ) x, y = zip(*valueList2d) si startTime est None : startTime = x[0] si endTime est 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 example #7
def fit_y(self, X, Y, x1, x2): len(X) != 0 # si X n`inclut qu`un seul point, la fonction on obtiendra la ligne y=Y[0] si 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 example #8
def remove_linear_BG_XAS_preedge( xmcd_data, scanparams, process_parameters=None, process_number= -1 ): """Devrait supprimer un bg linéaire basé sur la moyenne de pré-bord""" ], 1) ) xas_bg = preedge_poly(xmcd_data["Energy"]) for 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 example #9
def fit_y(self, X, Y, x1, x2) : len(X) != 0 # si X n`inclut qu`un seul point, la fonction obtiendra la ligne y=Y[0] si 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 example #10
def __init__( self, roots, weights=None, hn=1.0, kn=1.0, wfunc=None, limits=None, monic=0,eval_func=None): 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`] = limits 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 # Remarque : eval_func sera ignoré lors de l`arithmétique self.__dict__[`_eval_func`] = eval_func