Python numpy.polyval() Examples
The following are 30
code examples of numpy.polyval().
You can vote up the ones you like or vote down the ones you don't like,
and go to the original project or source file by following the links above each example.
You may also want to check out all available functions/classes of the module
numpy
, or try the search function
.
Example #1
Source File: ci.py From allantools with GNU Lesser General Public License v3.0 | 6 votes |
def detrend(x, deg=1): """ remove polynomial from data. used by autocorr_noise_id() Parameters ---------- x: numpy.array time-series deg: int degree of polynomial to remove from x Returns ------- x_detrended: numpy.array detrended time-series """ t = range(len(x)) p = np.polyfit(t, x, deg) residual = x - np.polyval(p, t) return residual ######################################################################## # Equivalent Degrees of Freedom
Example #2
Source File: elements.py From oopt-gnpy with BSD 3-Clause "New" or "Revised" License | 6 votes |
def _nf(self, type_def, nf_model, nf_fit_coeff, gain_min, gain_flatmax, gain_target): # if hybrid raman, use edfa_gain_flatmax attribute, else use gain_flatmax #gain_flatmax = getattr(params, 'edfa_gain_flatmax', params.gain_flatmax) pad = max(gain_min - gain_target, 0) gain_target += pad dg = max(gain_flatmax - gain_target, 0) if type_def == 'variable_gain': g1a = gain_target - nf_model.delta_p - dg nf_avg = lin2db(db2lin(nf_model.nf1) + db2lin(nf_model.nf2) / db2lin(g1a)) elif type_def == 'fixed_gain': nf_avg = nf_model.nf0 elif type_def == 'openroadm': pin_ch = self.pin_db - lin2db(self.nch) # model OSNR = f(Pin) nf_avg = pin_ch - polyval(nf_model.nf_coef, pin_ch) + 58 elif type_def == 'advanced_model': nf_avg = polyval(nf_fit_coeff, -dg) else: assert False, "Unrecognized amplifier type, this should have been checked by the JSON loader" return nf_avg + pad, pad
Example #3
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 6 votes |
def contour_entropy(self): """ Returns: """ try: import pylab as plt except ImportError: import matplotlib.pyplot as plt s_coeff = np.polyfit(self.volumes, self.entropy.T, deg=self._fit_order) s_grid = np.array([np.polyval(s_coeff, v) for v in self.volumes]).T x, y = self.meshgrid() plt.contourf(x, y, s_grid) plt.plot(self.get_minimum_energy_path(), self.temperatures) plt.xlabel("Volume [$\AA^3$]") plt.ylabel("Temperature [K]")
Example #4
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 6 votes |
def contour_pressure(self): """ Returns: """ try: import pylab as plt except ImportError: import matplotlib.pyplot as plt x, y = self.meshgrid() p_coeff = np.polyfit(self.volumes, self.pressure.T, deg=self._fit_order) p_grid = np.array([np.polyval(p_coeff, v) for v in self._volumes]).T plt.contourf(x, y, p_grid) plt.plot(self.get_minimum_energy_path(), self.temperatures) plt.xlabel("Volume [$\AA^3$]") plt.ylabel("Temperature [K]")
Example #5
Source File: Math.py From pyberny with Mozilla Public License 2.0 | 6 votes |
def fit_cubic(y0, y1, g0, g1): """Fit cubic polynomial to function values and derivatives at x = 0, 1. Returns position and function value of minimum if fit succeeds. Fit does not succeeds if 1. polynomial doesn't have extrema or 2. maximum is from (0,1) or 3. maximum is closer to 0.5 than minimum """ a = 2 * (y0 - y1) + g0 + g1 b = -3 * (y0 - y1) - 2 * g0 - g1 p = np.array([a, b, g0, y0]) r = np.roots(np.polyder(p)) if not np.isreal(r).all(): return None, None r = sorted(x.real for x in r) if p[0] > 0: maxim, minim = r else: minim, maxim = r if 0 < maxim < 1 and abs(minim - 0.5) > abs(maxim - 0.5): return None, None return minim, np.polyval(p, minim)
Example #6
Source File: wave.py From ocelot with GNU General Public License v3.0 | 6 votes |
def calc_phase_delay(coeff, w, w0): """ expression for the phase -- coeff[0] + coeff[1]*(w - w0)/1! + coeff[2]*(w - w0)**2/2! + coeff[3]*(w - w0)**3/3! coeff is a list with coeff[0] =: measured in [rad] --- phase coeff[1] =: measured in [fm s ^ 1] --- group delay coeff[2] =: measured in [fm s ^ 2] --- group delay dispersion (GDD) coeff[3] =: measured in [fm s ^ 3] --- third-order dispersion (TOD) ... """ delta_w = w - w0 _logger.debug('calculating phase delay') _logger.debug(ind_str + 'coeffs for compression = {}'.format(coeff)) coeff_norm = [ci / (1e15) ** i / factorial(i) for i, ci in enumerate(coeff)] coeff_norm = list(coeff_norm)[::-1] _logger.debug(ind_str + 'coeffs_norm = {}'.format(coeff_norm)) delta_phi = np.polyval(coeff_norm, delta_w) _logger.debug(ind_str + 'delta_phi[0] = {}'.format(delta_phi[0])) _logger.debug(ind_str + 'delta_phi[-1] = {}'.format(delta_phi[-1])) _logger.debug(ind_str + 'done') return delta_phi
Example #7
Source File: test_pvsystem.py From pvlib-python with BSD 3-Clause "New" or "Revised" License | 6 votes |
def test_PVSystem_sapm_effective_irradiance(sapm_module_params, mocker): system = pvsystem.PVSystem(module_parameters=sapm_module_params) mocker.spy(pvsystem, 'sapm_effective_irradiance') poa_direct = 900 poa_diffuse = 100 airmass_absolute = 1.5 aoi = 0 p = (sapm_module_params['A4'], sapm_module_params['A3'], sapm_module_params['A2'], sapm_module_params['A1'], sapm_module_params['A0']) f1 = np.polyval(p, airmass_absolute) expected = f1 * (poa_direct + sapm_module_params['FD'] * poa_diffuse) out = system.sapm_effective_irradiance( poa_direct, poa_diffuse, airmass_absolute, aoi) pvsystem.sapm_effective_irradiance.assert_called_once_with( poa_direct, poa_diffuse, airmass_absolute, aoi, sapm_module_params) assert_allclose(out, expected, atol=0.1)
Example #8
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 6 votes |
def get_minimum_energy_path(self, pressure=None): """ Args: pressure: Returns: """ if pressure is not None: raise NotImplemented() v_min_lst = [] for c in self._coeff.T: v_min = np.roots(np.polyder(c, 1)) p_der2 = np.polyder(c, 2) p_val2 = np.polyval(p_der2, v_min) v_m_lst = v_min[p_val2 > 0] if len(v_m_lst) > 0: v_min_lst.append(v_m_lst[0]) else: v_min_lst.append(np.nan) return np.array(v_min_lst)
Example #9
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 6 votes |
def interpolate_volume(self, volumes, fit_order=None): """ Args: volumes: fit_order: Returns: """ if fit_order is not None: self._fit_order = fit_order new = self.copy() new.volumes = volumes new.energies = np.array([np.polyval(self._coeff, v) for v in volumes]).T return new
Example #10
Source File: test_dltisys.py From GraphicDesignPatternByPython with MIT License | 6 votes |
def test_auto(self): # Test bode() magnitude calculation. # 1st order low-pass filter: H(s) = 0.3 / (z - 0.2), system = TransferFunction(0.3, [1, -0.2], dt=0.1) w = np.array([0.1, 0.5, 1, np.pi]) w2, mag, phase = dbode(system, w=w) jw = np.exp(w * 1j) y = np.polyval(system.num, jw) / np.polyval(system.den, jw) # Test mag expected_mag = 20.0 * np.log10(abs(y)) assert_almost_equal(mag, expected_mag) # Test phase expected_phase = np.rad2deg(np.angle(y)) assert_almost_equal(phase, expected_phase)
Example #11
Source File: test_dltisys.py From GraphicDesignPatternByPython with MIT License | 6 votes |
def test_auto(self): # Test dfreqresp() real part calculation. # 1st order low-pass filter: H(z) = 1 / (z - 0.2), system = TransferFunction(1, [1, -0.2], dt=0.1) w = [0.1, 1, 10, 100] w, H = dfreqresp(system, w=w) jw = np.exp(w * 1j) y = np.polyval(system.num, jw) / np.polyval(system.den, jw) # test real expected_re = y.real assert_almost_equal(H.real, expected_re) # test imag expected_im = y.imag assert_almost_equal(H.imag, expected_im)
Example #12
Source File: test_savitzky_golay.py From GraphicDesignPatternByPython with MIT License | 6 votes |
def alt_sg_coeffs(window_length, polyorder, pos): """This is an alternative implementation of the SG coefficients. It uses numpy.polyfit and numpy.polyval. The results should be equivalent to those of savgol_coeffs(), but this implementation is slower. window_length should be odd. """ if pos is None: pos = window_length // 2 t = np.arange(window_length) unit = (t == pos).astype(int) h = np.polyval(np.polyfit(t, unit, polyorder), t) return h
Example #13
Source File: test_ltisys.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def test_output(self): # Test freqresp() output calculation. # 1st order low-pass filter: H(s) = 1 / (s + 1) system = lti([1], [1, 1]) w = [0.1, 1, 10, 100] w, H = freqresp(system, w=w) s = w * 1j expected = np.polyval(system.num, s) / np.polyval(system.den, s) assert_almost_equal(H.real, expected.real) assert_almost_equal(H.imag, expected.imag)
Example #14
Source File: _continuous_distns.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def _stats(self, b, moments='mv'): mu, mu2, g1, g2 = None, None, None, None if 'm' in moments: mask = b > 1 bt = np.extract(mask, b) mu = valarray(np.shape(b), value=np.inf) np.place(mu, mask, bt / (bt-1.0)) if 'v' in moments: mask = b > 2 bt = np.extract(mask, b) mu2 = valarray(np.shape(b), value=np.inf) np.place(mu2, mask, bt / (bt-2.0) / (bt-1.0)**2) if 's' in moments: mask = b > 3 bt = np.extract(mask, b) g1 = valarray(np.shape(b), value=np.nan) vals = 2 * (bt + 1.0) * np.sqrt(bt - 2.0) / ((bt - 3.0) * np.sqrt(bt)) np.place(g1, mask, vals) if 'k' in moments: mask = b > 4 bt = np.extract(mask, b) g2 = valarray(np.shape(b), value=np.nan) vals = (6.0*np.polyval([1.0, 1.0, -6, -2], bt) / np.polyval([1.0, -7.0, 12.0, 0.0], bt)) np.place(g2, mask, vals) return mu, mu2, g1, g2
Example #15
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 5 votes |
def get_free_energy_p(self): """ Returns: """ coeff = np.polyfit(self._volumes, self.energies.T, deg=self._fit_order) return np.polyval(coeff, self.get_minimum_energy_path())
Example #16
Source File: _continuous_distns.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def _stats(self, s): p = np.exp(s*s) mu = np.sqrt(p) mu2 = p*(p-1) g1 = np.sqrt((p-1))*(2+p) g2 = np.polyval([1, 2, 3, 0, -6.0], p) return mu, mu2, g1, g2
Example #17
Source File: _continuous_distns.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def _stats(self): p = np.e mu = np.sqrt(p) mu2 = p * (p - 1) g1 = np.sqrt((p - 1)) * (2 + p) g2 = np.polyval([1, 2, 3, 0, -6.0], p) return mu, mu2, g1, g2
Example #18
Source File: page_dewarp.py From page_dewarp with MIT License | 5 votes |
def project_xy(xy_coords, pvec): # get cubic polynomial coefficients given # # f(0) = 0, f'(0) = alpha # f(1) = 0, f'(1) = beta alpha, beta = tuple(pvec[CUBIC_IDX]) poly = np.array([ alpha + beta, -2*alpha - beta, alpha, 0]) xy_coords = xy_coords.reshape((-1, 2)) z_coords = np.polyval(poly, xy_coords[:, 0]) objpoints = np.hstack((xy_coords, z_coords.reshape((-1, 1)))) image_points, _ = cv2.projectPoints(objpoints, pvec[RVEC_IDX], pvec[TVEC_IDX], K, np.zeros(5)) return image_points
Example #19
Source File: test_collocation.py From pySDC with BSD 2-Clause "Simplified" License | 5 votes |
def check_canintegratepolynomials(collclass,t_start,t_end): for M in range(2,13): coll = collclass(M, t_start, t_end) # some basic consistency tests assert np.size(coll.nodes)==np.size(coll.weights), "For node type " + type[0] + ", number of entries in nodes and weights is different" assert np.size(coll.nodes)==M, "For node type " + type[0] + ", requesting M nodes did not produce M entries in nodes and weights" # generate random set of polynomial coefficients poly_coeff = np.random.rand(coll.order-1) # evaluate polynomial at collocation nodes poly_vals = np.polyval(poly_coeff, coll.nodes) # use python's polyint function to compute anti-derivative of polynomial poly_int_coeff = np.polyint(poly_coeff) # Compute integral from 0.0 to 1.0 int_ex = np.polyval(poly_int_coeff, t_end) - np.polyval(poly_int_coeff, t_start) # use quadrature rule to compute integral int_coll = coll.evaluate(coll.weights, poly_vals) # For large values of M, substantial differences from different round of error have to be considered assert abs(int_ex - int_coll) < 1e-13, "For node type " + coll.__class__.__name__ + ", failed to integrate polynomial of degree " + str(coll.order-1) + " exactly. Error: %5.3e" % abs(int_ex - int_coll) # TEST 2: # Check that the Qmat entries are equal to the sum of Smat entries # ----------------------------------------------------------------
Example #20
Source File: test_ltisys.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def test_04(self): # Test bode() phase calculation. # 1st order low-pass filter: H(s) = 1 / (s + 1) system = lti([1], [1, 1]) w = [0.1, 1, 10, 100] w, mag, phase = bode(system, w=w) jw = w * 1j y = np.polyval(system.num, jw) / np.polyval(system.den, jw) expected_phase = np.arctan2(y.imag, y.real) * 180.0 / np.pi assert_almost_equal(phase, expected_phase)
Example #21
Source File: _discrete_distns.py From GraphicDesignPatternByPython with MIT License | 5 votes |
def _stats(self, p): mu = 1.0/p qr = 1.0-p var = qr / p / p g1 = (2.0-p) / sqrt(qr) g2 = np.polyval([1, -6, 6], p)/(1.0-p) return mu, var, g1, g2
Example #22
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 5 votes |
def get_entropy_p(self): """ Returns: """ s_coeff = np.polyfit(self._volumes, self.entropy.T, deg=self._fit_order) return np.polyval(s_coeff, self.get_minimum_energy_path())
Example #23
Source File: stack.py From grizli with MIT License | 5 votes |
def scale_AxT(p, Ax, spec_wave, Nphot, Next): """ Scale spectrum templates by polynomial function """ from scipy import polyval scale = np.ones(Ax.shape[1]) scale[:-Nphot] = polyval(p[::-1]/10., (spec_wave-1.e4)/1000.) AxT = Ax*scale for i in range(Next): AxT[i, :] /= scale return AxT
Example #24
Source File: thermo_bulk.py From pyiron with BSD 3-Clause "New" or "Revised" License | 5 votes |
def get_free_energy(self, vol, pressure=None): """ Args: vol: pressure: Returns: """ if not pressure: return np.polyval(self._coeff, vol) else: raise NotImplementedError()
Example #25
Source File: test_polyfit.py From pwtools with BSD 3-Clause "New" or "Revised" License | 5 votes |
def test_compare_numpy(): x = np.sort(np.random.rand(10)) y = np.random.rand(10) yy1 = np.polyval(np.polyfit(x, y, 3), x) scale = [{'scale': False}, {'scale': True}] scale_vand = [{'scale_vand': False}, {'scale_vand': True}] kwd_lst = make_kwd_lst(scale, scale_vand) for kwds in kwd_lst: yy2 = num.PolyFit1D(x, y, 3, **kwds)(x) assert np.allclose(yy1, yy2)
Example #26
Source File: num.py From pwtools with BSD 3-Clause "New" or "Revised" License | 5 votes |
def __init__(self, points, values, *args, **kwds): """ Parameters ---------- points : nd array (npoints, ndim) values : 1d array (npoints,) **kwds : keywords to polyfit() """ self.points = self._fix_shape_init(points) assert self.points.ndim == 2, "points is not 2d array" self.values = values self.fitfunc = polyfit self.evalfunc = polyval self.fit = self.fitfunc(self.points, self.values, *args, **kwds)
Example #27
Source File: num.py From pwtools with BSD 3-Clause "New" or "Revised" License | 5 votes |
def polyval(fit, points, der=0): """Evaluate polynomial generated by :func:`polyfit` on `points`. Parameters ---------- fit, points : see :func:`polyfit` der : int, optional Derivative order. Only for 1D, uses np.polyder(). Notes ----- For 1D we provide "analytic" derivatives using np.polyder(). For ND, we didn't implement an equivalent machinery. For 2D, you might get away with fitting a bispline (see Interpol2D) and use it's derivs. For ND, try rbf.py's RBF interpolator which has at least 1st derivatives for arbitrary dimensions. See Also -------- :class:`PolyFit`, :class:`PolyFit1D`, :func:`polyfit` """ assert points.ndim == 2, "points must be 2d array" pscale, pmin = fit['pscale'], fit['pmin'] vscale, vmin = fit['vscale'], fit['vmin'] if der > 0: assert points.shape[1] == 1, "deriv only for 1d poly (ndim=1)" # ::-1 b/c numpy stores poly coeffs in reversed order dcoeffs = np.polyder(fit['coeffs'][::-1], m=der) return np.polyval(dcoeffs, (points[:,0] - pmin[0,0]) / pscale[0,0]) / \ pscale[0,0]**der * vscale else: vand = vander((points - pmin) / pscale, fit['deg']) return np.dot(vand, fit['coeffs']) * vscale + vmin
Example #28
Source File: fractal_correlation.py From NeuroKit with MIT License | 5 votes |
def _fractal_correlation_plot(r_vals, corr, d2): fit = 2 ** np.polyval(d2, np.log2(r_vals)) plt.loglog(r_vals, corr, "bo") plt.loglog(r_vals, fit, "r", label=r"$D2$ = %0.3f" % d2[0]) plt.title("Correlation Dimension") plt.xlabel(r"$\log_{2}$(r)") plt.ylabel(r"$\log_{2}$(c)") plt.legend() plt.show()
Example #29
Source File: measures.py From nolds with MIT License | 5 votes |
def plot_reg(xvals, yvals, poly, x_label="x", y_label="y", data_label="data", reg_label="regression line", fname=None): """ Helper function to plot trend lines for line-fitting approaches. This function will show a plot through ``plt.show()`` and close it after the window has been closed by the user. Args: xvals (list/array of float): list of x-values yvals (list/array of float): list of y-values poly (list/array of float): polynomial parameters as accepted by ``np.polyval`` Kwargs: x_label (str): label of the x-axis y_label (str): label of the y-axis data_label (str): label of the data reg_label(str): label of the regression line fname (str): file name (if not None, the plot will be saved to disc instead of showing it though ``plt.show()``) """ # local import to avoid dependency for non-debug use import matplotlib.pyplot as plt plt.plot(xvals, yvals, "bo", label=data_label) if not (poly is None): plt.plot(xvals, np.polyval(poly, xvals), "r-", label=reg_label) plt.xlabel(x_label) plt.ylabel(y_label) plt.legend(loc="best") if fname is None: plt.show() else: plt.savefig(fname) plt.close()
Example #30
Source File: test_ltisys.py From Computable with MIT License | 5 votes |
def test_imag_part(self): # Test freqresp() imaginary part calculation. # 1st order low-pass filter: H(s) = 1 / (s + 1) system = lti([1], [1, 1]) w = [0.1, 1, 10, 100] w, H = freqresp(system, w=w) jw = w * 1j y = np.polyval(system.num, jw) / np.polyval(system.den, jw) expected_im = y.imag assert_almost_equal(H.imag, expected_im)