def test_interpolationLagrange(l): Xs = l[0] Ys = l[1] new_x = l[2] _, val = interpolationLagrange(Xs, Ys, new_x) yn = interpolate.barycentric_interpolate(Xs, Ys, new_x) assert np.round(val, 3) == np.round(yn, 3)
def test_interpolateNewton(s): Xs = [1, 4, 6, 5, 7] Ys = [0, 1.386294, 1.791759, 1.609438, 1.82] new_x = 3 _, val = interpolateNewton(Xs, Ys, x0=new_x) yn = interpolate.barycentric_interpolate(Xs, Ys, new_x) assert np.round(val, 3) == np.round(yn, 3)
def interpolation(): samples = 77 rec_period = 4 sampling_rate = samples/rec_period time = np.linspace(0, rec_period, samples) sin = np.sin(time*3.75*np.pi) pad_count = 23 padded_sin = np.pad(np.sin(time*3.75*np.pi), (0,pad_count), 'constant') fft = np.fft.rfft(sin) fft_padded = np.fft.rfft(padded_sin) bins = (np.fft.rfftfreq(len(sin))*sampling_rate)[1:] #print(np.insert(bins, 7, 1.875)) new_bins = np.insert(bins, 7, 1.875) interpolation_fun = interpolate.interp1d(bins, np.abs(fft)[1:]*2/samples, "linear") #quadratic asd = np.fft.rfftfreq(100)[2:-1]*sampling_rate interpolationb = interpolate.barycentric_interpolate(bins, np.abs(fft)[1:]*2/samples, new_bins) plt.subplot(221) plt.plot(time, sin) plt.subplot(222) plt.plot(bins, (np.abs(fft))[1:]*2/samples) plt.plot(new_bins, [interpolation_fun(i) for i in new_bins], "o") plt.plot(new_bins, interpolationb) plt.subplot(223) plt.plot(np.linspace(0, (samples+pad_count)*rec_period/float(samples), samples+pad_count), padded_sin) plt.subplot(224) plt.plot((np.fft.rfftfreq(len(padded_sin))*sampling_rate)[1:], (np.abs(fft_padded))[1:]*2/samples, "o") #matplotlib2tikz.save( 'myfile.tikz' ) plt.show()
def potential_discret(x_min, x_max, n_point, interp_type, potential_decl): """ discretises the potential by using linear/cubic/polynomial interpolation and saves the results into a file named potential.dat Args: x_min: minimal x-value x_max: maximal x-value n_point: number of points between x_min and x_max interp_type: type of interpolation potential_decl: array of points defining the potnetial **return**: * **potential_dat** - array of the x_values in the first column \ and the y-values of the potential in the second column """ x_values = np.linspace(x_min, x_max, n_point) if interp_type == "linear": potential = np.interp(x_values, potential_decl[:, 0], potential_decl[:, 1]) elif interp_type == "polynomial": potential = interpolate.barycentric_interpolate(potential_decl[:, 0], potential_decl[:, 1], x_values) elif interp_type == "cspline": potential = interpolate.CubicSpline(potential_decl[:, 0], potential_decl[:, 1], bc_type="natural")(x_values) potential_dat = np.array(list(zip(x_values, potential))) np.savetxt("potential.dat", potential_dat) return potential_dat
def findAnswer(u,deg): x = np.arange(1,deg+1,dtype=np.int64) y = u(x) fitsum = 1 for i in range(2,len(x)+1): fitsum += np.round(interpolate.barycentric_interpolate(x[:i],y[:i],i+1)) return fitsum
def interpolate(self, z, f): """""" from scipy.interpolate import barycentric_interpolate import numpy as np msg = "Can't interpolate outside grid domain" assert np.array([z]).min() >= self.zmin, msg assert np.array([z]).max() <= self.zmax, msg return barycentric_interpolate(self.zg, f, z)
def update(n: int): label = f'{n} uniform nodes' print(label) samples = np.linspace(-1, 1, n) interpolated = barycentric_interpolate(samples, runge_function(samples), x) points.set_data(samples, runge_function(samples)) fit.set_ydata(interpolated) text.set_text(label) return points, fit, text
def update(n: int): label = f'{n} Chebyshev distributed nodes' print(label) samples = chebyshev_nodes(n) interpolated = barycentric_interpolate(samples, runge_function(samples), x) points.set_data(samples, runge_function(samples)) fit.set_ydata(interpolated) text.set_text(label) return points, fit, text
def test_g(self): """Example taken from: https://en.wikiversity.org/wiki/Numerical_Analysis/Neville%27s_algorithm_examples""" xs = [16, 64, 100] ys = [g(x) for x in xs] x0 = 81 y0 = self.algorithm(xs, ys, x0) bi0 = barycentric_interpolate(xs, ys, x0) self.assertAlmostEqual(bi0, np.array(y0), 4)
def test_g(self): """Example taken from: https://en.wikiversity.org/wiki/Numerical_Analysis/Neville%27s_algorithm_examples""" xs = [16, 64, 100] ys = [g(x) for x in xs] x0 = 81 y0 = self.algorithm(xs, ys, x0) bi0 = barycentric_interpolate(xs, ys, x0) self.assertTrue(isclose(y0, 0.106, rel_tol=1e-02)) self.assertTrue(isclose(bi0, y0, rel_tol=1e-02))
def interpolate(self, z, f): """""" # from numpy.polynomial.hermite import hermfit, hermval # c, res = hermfit(self.zg, f, deg=self.N, full=True) # return hermval(z, c) from scipy.interpolate import barycentric_interpolate import numpy as np msg = "Can't interpolate outside grid domain" assert np.array([z]).min() >= self.zmin, msg assert np.array([z]).max() <= self.zmax, msg return barycentric_interpolate(self.zg, f, z)
def prep_data(self,data, quantile=0.1,nbins=1000, interpolate=False,dB=False, substract_background=False): """ This method preprocesses data (e.g., substract background). """ prov = self.provider prep_data = deepcopy(data) array = data.get_parameter("intensity") nt = data.naxis[0] ; nf = data.naxis[1] frequency = data.get_parameter("frequency") background = data.get_parameter("background") int_time = data.get_parameter("integration_time") bandwidth = data.get_parameter("bandwidth") rms = 1./np.sqrt(int_time*bandwidth) if (prov == "gsfc"): if (interpolate): where_ok = np.where(background > 0.0) background=barycentric_interpolate(frequency[where_ok],background[where_ok], frequency) snr = np.zeros((nt,nf),dtype=np.float32) for j in range(nf): array_j = array[:,j]*background[j] if (sum(array_j) == 0.0): continue array_j = array_j - background[j] snr[:,j] = array_j/(background[j]*rms) if (substract_background): array[:,j]=array_j if (dB): array = to_dB(array.clip(MIN_VAL,array.max())) snr = to_dB(snr.clip(MIN_VAL,snr.max())) background = to_dB(background.clip(MIN_VAL,background.max())) if (substract_background): intensity_units = "Intensity (dB)" else: intensity_units = "Intensity above background (dB)" else: if (substract_background): intensity_units = "Intensity" prep_data.set_parameter("intensity_units",intensity_units) prep_data.set_parameter("intensity",array) prep_data.set_parameter("background",background) prep_data.set_parameter("snr",snr) return prep_data
def test_f(self): """Interpolation of function f with a polynomial p at the equidistant points x[k] = −1 + 2 * (k / n), k = 0, ..., n.""" n = 20 # n points, so polynomial would be of degree n - 1. xs = [-1 + 2 * (k / n) for k in range(n)] ys = [f(x) for x in xs] for i in range(20): x0 = uniform(-1.0, 1.0) y0 = self.algorithm(xs, ys, x0) bi0 = barycentric_interpolate(xs, ys, x0) self.assertAlmostEqual(bi0, np.array(y0), 4)
def test_f(self): """Interpolation of function f with a polynomial p at the equidistant points x[k] = −1 + 2 * (k / n), k = 0, ..., n.""" n = 20 # n points, so polynomial would be of degree n - 1. xs = [-1 + 2 * (k / n) for k in range(n)] ys = [f(x) for x in xs] for i in range(20): x0 = uniform(-1.0, 1.0) y0 = self.algorithm(xs, ys, x0) bi0 = barycentric_interpolate(xs, ys, x0) # f0 = f(x0) # e0 = fabs(y0 - f(x0)) # print("e(%d) = %f\n" % (x0, e0)) self.assertTrue(isclose(bi0, y0))
def __call__(self, x): return _interpolate.barycentric_interpolate(self.x, self.y, x)
from numpy.polynomial import chebyshev import numpy as np from scipy.interpolate import barycentric_interpolate def runge(x): """Función de Runge.""" return 1 / (1 + 25 * x**2) N = 3 # Nodos de interpolación xp = array([3, 8, 20]) fp = runge(xp) x = np.linspace(0, 20) y = barycentric_interpolate(xp, fp, x) #------- from numpy.polynomial import chebyshev coeffs_cheb = [0] * 3 + [1] T3 = chebyshev.Chebyshev(coeffs_cheb, [0, 20]) xp_ch = T3.roots()
plt.loglog(Re, cD, 'o', newRe, newcD, '-') # first plot is circles, new plot is dashes plt.title('Re vs cD on loglog scale') plt.xlabel('logRe') plt.ylabel('logcD') print "\n\n Cubic spline interpolation results:" # printing the numerical value of the function at the given new Re values when using the cubic spline interpolation print "Value at Re = 5: " + (str(f(5))) print "Value at Re = 50: " + (str(f(50))) print "Value at Re = 500: " + (str(f(500))) print "Value at Re = 5000: " + (str(f(5000))) print "\n\n Polynomial interpolation results:" # printing the numerical value of the function at the given new Re values when using the polynomial/barycentric interpolation print "Value at Re = 5: " + (str(interpolate.barycentric_interpolate( Re, cD, 5))) print "Value at Re = 50: " + (str( interpolate.barycentric_interpolate(Re, cD, 50))) print "Value at Re = 500: " + (str( interpolate.barycentric_interpolate(Re, cD, 500))) print "Value at Re = 5000: " + (str( interpolate.barycentric_interpolate(Re, cD, 5000))) lRe = np.log(Re) lcD = np.log(cD) p = polyFit( lRe, lcD, 3 ) # this gives the coefficients of the polynomial on the logged values of Re and cD print "The polynomial interpolation results are: " print p
return 1 / (1 + 25 * x**2) # fine grid for plotting x_fine = np.linspace(-1, 1, 1000) # draw the true function plt.plot(x_fine, runge_fn(x_fine), '--') if USE_CHEB: ns = (10, 20, 30) else: ns = (6, 10, 12, 16) for n in ns: # interpolation points if USE_CHEB: zi = np.linspace(0, 1, n) xi = -1 + (1 + np.cos(np.pi * (1 - zi))) else: xi = np.linspace(-1, 1, n) yi = runge_fn(xi) # interpolate the function y_fine = barycentric_interpolate(xi, yi, x_fine) plt.plot(x_fine, y_fine, label='n = {}'.format(n)) plt.legend() plt.show()
np.save('ion.npy', ion) np.save('lz.npy', lz) np.save('dm.npy', dm) dm = 1 - dm else: ion = np.load('ion.npy') lz = np.load('lz.npy') dm = 1 - np.load('dm.npy') trace = np.einsum('abb->a', dm) for a, b in zip(ion, trace): print(f'{a} : {2*b.real} : {a-2*b.real}') cycles_up = np.linspace(min_cycles, max_cycles, 1000) ion_up = barycentric_interpolate(cycles_sweep, ion, cycles_up) lz_up = barycentric_interpolate(cycles_sweep, lz, cycles_up) dm_up = barycentric_interpolate(cycles_sweep, dm, cycles_up, axis=0) diagonal = np.einsum('abb->ab', dm_up).real right = (diagonal[:, 2] + diagonal[:, 3]) / 2 + dm_up[:, 2, 3].imag left = (diagonal[:, 2] + diagonal[:, 3]) / 2 - dm_up[:, 2, 3].imag diagonal[:, 2] = right diagonal[:, 3] = left labels = [ r'2$\sigma_g$', r'2$\sigma_u$', r'1$\pi_{u+}$', r'1$\pi_{u-}$', r'3$\sigma_g$' ] linestyles = reversed(['-', '--', ':', '-.', '-']) for d, l, ls in reversed(list(zip(np.transpose(diagonal), labels,
def runge_function(x: float) -> float: return 1 / (1 + 25 * x * x) # Number of datapoints (nodes) to sample from node_count = 40 spaced_x = np.array(chebyshev_nodes(node_count)) uniform_x = np.linspace(-1, 1, node_count) interp_cheb_x = np.linspace(min(spaced_x), max(spaced_x), 150) interp_uniform_x = np.linspace(min(uniform_x), max(uniform_x), 150) actual_x = np.linspace(-1, 1, 150) chebyshev_y = barycentric_interpolate(spaced_x, runge_function(spaced_x), interp_cheb_x) uniform_y = barycentric_interpolate(uniform_x, runge_function(uniform_x), interp_uniform_x) actual_y = runge_function(actual_x) # Plotting code fig, (ax1, ax2) = plt.subplots(nrows=2) ax1.plot(actual_x, actual_y, 'k') ax1.plot(interp_cheb_x, chebyshev_y, '--r') ax2.plot(actual_x, actual_y, 'k') ax2.plot(interp_uniform_x, uniform_y, '--b') ax2.set(ylim=(-1, 1.2)) ax1.grid() ax2.grid()
def __call__(self, x): return _interpolate.barycentric_interpolate(self.x, self.y, x)
def test_int_input(self): x = 1000 * np.arange(1, 11) # np.prod(x[-1] - x[:-1]) overflows y = np.arange(1, 11) value = barycentric_interpolate(x, y, 1000 * 9.5) assert_almost_equal(value, 9.5)
print(ionization_all) print('lz_all', lz_all.shape) print('ionization_all', ionization_all.shape) lz_all = np.concatenate([np.flip(lz_all, axis=0), [0], lz_all]) ionization_all = np.concatenate( [np.flip(ionization_all, axis=0), [0], ionization_all]) intens_test = 1e13 * np.sin(0.5 * np.pi * np.array(range(1, 9)) / 8)**4 efield_low = -np.cos(0.5 * np.pi * np.array(range(0, 17)) / 8) intens_low = 1e13 * efield_low**2 intens_high = np.geomspace(1e11, 1e13, 100) efield_high = np.sqrt(intens_high / 1e13) lz_high = barycentric_interpolate(efield_low, lz_all, efield_high) ionization_high = barycentric_interpolate(efield_low, ionization_all, efield_high) ratio = 0.8 plt.figure(figsize=(6.4 * ratio, 4.8 * ratio)) #final_ionization = np.sum(ionization_high,axis=1)*time_step #final_lz = lzAll_high[:,-1] duration = 202.58 rabi_freq = efield_high * 1.81 * np.sqrt(1e13 / (3.51e16)) few_level = 0.78 * np.sin(0.25 * duration * rabi_freq)**2 plt.semilogx(intens_high, lz_high) plt.semilogx(intens_high, few_level, linestyle='--') plt.semilogx(intens_high, ionization_high, linestyle=':') plt.semilogx(intens_low[-8:], ionization_all[-8:],
def interpola(l, inferior, superior): """ --------------------------------------------------------------------- Recibe las lineas con la informacion a interpolar. La primera linea es el dato TLE y las otras dos son las lineas de los datos CODS cuyas fechas encierran a la fecha del TLE. --------------------------------------------------------------------- input l: cadena con fecha hora x y z vx vy vz (str) inferior: cadena con fecha hora x y z vx vy vz (str) superior: cadena con fecha hora x y z vx vy vz (str) output lineaInterpol: cadena con fecha & hora(TLE) + datos interpolados """ lcampos = l.split() dicampos = inferior.split() dscampos = superior.split() # fecha inferior di = inferior[:19] di = datetime.strptime(di, '%Y/%m/%d %H:%M:%S') di_int = toTimestamp(di) #fecha superior ds = superior[:19] ds = datetime.strptime(ds, '%Y/%m/%d %H:%M:%S') ds_int = toTimestamp(ds) #fecha tle dt = l[:19] dt = datetime.strptime(dt, '%Y-%m-%d %H:%M:%S') dt_int = toTimestamp(dt) x_array = [di_int, ds_int] x_new = dt_int # Interpolacion en x fx_array = [float(dicampos[2]), float(dscampos[2])] yx_new = barycentric_interpolate(x_array, fx_array, x_new) # Interpolacion en y fy_array = [float(dicampos[3]), float(dscampos[3])] yy_new = barycentric_interpolate(x_array, fy_array, x_new) # Interpolacion en z fz_array = [float(dicampos[4]), float(dscampos[4])] yz_new = barycentric_interpolate(x_array, fz_array, x_new) # lineaInterpol=lcampos[0]+' '+lcampos[1]+' '+str(yx_new)+' '+str(yy_new)+' '+str(yz_new)+'\n' # Interpolacion en vx fvx_array = [float(dicampos[5]), float(dscampos[5])] yvx_new = barycentric_interpolate(x_array, fvx_array, x_new) # Interpolacion en vy fvy_array = [float(dicampos[6]), float(dscampos[6])] yvy_new = barycentric_interpolate(x_array, fvy_array, x_new) # Interpolacion en vz fvz_array = [float(dicampos[7]), float(dscampos[7])] yvz_new = barycentric_interpolate(x_array, fvz_array, x_new) lineaInterpol = lcampos[0] + ' ' + lcampos[1] + ' ' + str( yx_new) + ' ' + str(yy_new) + ' ' + str(yz_new) + ' ' + str( yvx_new) + ' ' + str(yvy_new) + ' ' + str(yvz_new) + '\n' return lineaInterpol
import numpy as np import polyFit import scipy from scipy import interpolate import matplotlib.pyplot as plt h=[0.0,1.525,3.050,4.575,6.1,7.625,9.15] #x values den=[1,0.8617,0.7385,0.6292,0.5328,0.4481,0.3741] #y values hrang=np.linspace(0,9.15,100) print 'Using Polynomial Interpolation: ', '\n' l_001=interpolate.barycentric_interpolate(h,den,(2,5)) #Using interpolate from scipy. Uses barycentric polynomial interpolation. Arguments: (x values, y values, points at which you wish to evaluate) print 'At 2km the density of air will be ', l_001[0] print 'At 5km the density of air will be ', l_001[1] ### print '\n', 'Using Cubic Splines: ', '\n' l_002=interpolate.interp1d(h,den,kind='cubic') #Interpolatioon from scipy. Uses cubic splines. Arguments: (x values, y values, order of splines) print 'At 2km the density of air will be ', l_002(2) #Calls for interpolation to be evaluated at argument print 'At 5km the density of air will be ', l_002(5) ### print '\n', 'Using Least Squares Fit: ', '\n'
import numpy as np import polyFit import scipy from scipy import interpolate import matplotlib.pyplot as plt h = [0.0, 1.525, 3.050, 4.575, 6.1, 7.625, 9.15] #x values den = [1, 0.8617, 0.7385, 0.6292, 0.5328, 0.4481, 0.3741] #y values hrang = np.linspace(0, 9.15, 100) print 'Using Polynomial Interpolation: ', '\n' l_001 = interpolate.barycentric_interpolate( h, den, (2, 5) ) #Using interpolate from scipy. Uses barycentric polynomial interpolation. Arguments: (x values, y values, points at which you wish to evaluate) print 'At 2km the density of air will be ', l_001[0] print 'At 5km the density of air will be ', l_001[1] ### print '\n', 'Using Cubic Splines: ', '\n' l_002 = interpolate.interp1d( h, den, kind='cubic' ) #Interpolatioon from scipy. Uses cubic splines. Arguments: (x values, y values, order of splines) print 'At 2km the density of air will be ', l_002( 2) #Calls for interpolation to be evaluated at argument print 'At 5km the density of air will be ', l_002(5)
plt.title('Re vs cD on loglog scale') plt.xlabel('logRe') plt.ylabel('logcD') print "\n\n Cubic spline interpolation results:" # printing the numerical value of the function at the given new Re values when using the cubic spline interpolation print "Value at Re = 5: " + (str(f(5))) print "Value at Re = 50: " + (str(f(50))) print "Value at Re = 500: " + (str(f(500))) print "Value at Re = 5000: " + (str(f(5000))) print "\n\n Polynomial interpolation results:" # printing the numerical value of the function at the given new Re values when using the polynomial/barycentric interpolation print "Value at Re = 5: " + (str(interpolate.barycentric_interpolate(Re,cD,5))) print "Value at Re = 50: " + (str(interpolate.barycentric_interpolate(Re,cD,50))) print "Value at Re = 500: " + (str(interpolate.barycentric_interpolate(Re,cD,500))) print "Value at Re = 5000: " + (str(interpolate.barycentric_interpolate(Re,cD,5000))) lRe=np.log(Re) lcD=np.log(cD) p = polyFit(lRe,lcD,3) # this gives the coefficients of the polynomial on the logged values of Re and cD print "The polynomial interpolation results are: " print p x = np.arange(np.log(Re[0]),np.log(Re[5]),0.1) # making a range of the relevant Re log values to use with our polyfit y = p[0]+x*(p[1])+(x**2)*(p[2])+(x**3)*(p[3]) # the polyfit
proj_low.append(ionization) #proj_low.append(1-np.sum(proj_low,axis=0)) proj_low = np.array(proj_low) proj_low = np.concatenate([ np.transpose(np.array([[0, 1, 0, 0, 0], [0, 1, 0, 0, 0]]))[:, None, :], proj_low ], axis=1) print(proj_low.shape) efield_low = np.sin(0.5 * np.pi * np.array(range(0, 9)) / 8) intens_low = 1e13 * efield_low**2 intens_high = np.linspace(0, 1e13, 100) proj_high = barycentric_interpolate(intens_low, proj_low, intens_high, axis=1) fig, axs = plt.subplots(1, 2, sharey=True) axs[0].plot(intens_high, proj_high[1, :, 0], label='H**O') axs[0].plot(intens_high, proj_high[2, :, 0], label='LUMO', linestyle='--') axs[0].plot(intens_high, proj_high[4, :, 0], label='Ionized', linestyle=':') other_right = 1 - proj_high[1, :, 0] - proj_high[2, :, 0] - proj_high[4, :, 0] axs[0].plot(intens_high, other_right, label='Other', linestyle='-.') axs[0].plot(intens_low[1:], proj_low[1, 1:, 0], linestyle='None',
def runge_function(x: float) -> float: return 1 / (1 + 25 * x * x) fig, ax = plt.subplots() fig.set_tight_layout(True) ax.grid() x = np.linspace(-1, 1, 200) # Persistent ax.plot(x, runge_function(x), 'k') n = 2 samples = chebyshev_nodes(n) interpolated = barycentric_interpolate(samples, runge_function(samples), x) # To be updated points, = ax.plot(samples, runge_function(samples), 'or') fit, = ax.plot(x, interpolated, ':b') text = ax.text(-1.08, 0.81, f'{n} uniform nodes') print(points) print(fit) def update(n: int): label = f'{n} Chebyshev distributed nodes' print(label) samples = chebyshev_nodes(n)
from pylab import * from scipy import interpolate, optimize from numpy import * # construct data point arrays first h = array([0.0, 1.525, 3.050, 4.575, 6.100, 7.625, 9.150]) rho = array([1.0, 0.8617, 0.7385, 0.6292, 0.5328, 0.4481, 0.3741]) # Part A # use Barycentric initally as the most direct path to an answer print "At 2km, the polynomial, interpolated value is:" print(str(interpolate.barycentric_interpolate(h, rho, 2.0))) print "And at 4km, the interpolated value is:" print(str(interpolate.barycentric_interpolate(h, rho, 4.0))) print "And at 8km, the interpolated value is:" print(str(interpolate.barycentric_interpolate(h, rho, 8.0))) # B: cubic spline fit = interpolate.interp1d(h, rho, kind='cubic') #set up fit, called as fit(value) print "At h=2, h=4 and h=8 respectively, using a cubic spline, rho=" print fit(2.0), ", ", fit(4.0), ", ", fit(8.0) # C: errors rho_actual = 0.67 print "Absolute error for polynomial interpolation:" err_abso_poly = np.abs(
def test_wrapper(self): P = BarycentricInterpolator(self.xs, self.ys) values = barycentric_interpolate(self.xs, self.ys, self.test_xs) assert_almost_equal(P(self.test_xs), values)
from pylab import * from scipy import interpolate, optimize from numpy import * # construct data point arrays first h = array([0.0,1.525,3.050,4.575,6.100,7.625,9.150]) rho = array([1.0,0.8617,0.7385,0.6292,0.5328,0.4481,0.3741]) # Part A # use Barycentric initally as the most direct path to an answer print "At 2km, the polynomial, interpolated value is:" print(str(interpolate.barycentric_interpolate(h,rho,2.0))) print "And at 4km, the interpolated value is:" print(str(interpolate.barycentric_interpolate(h,rho,4.0))) print "And at 8km, the interpolated value is:" print(str(interpolate.barycentric_interpolate(h,rho,8.0))) # B: cubic spline fit = interpolate.interp1d(h,rho,kind='cubic') #set up fit, called as fit(value) print "At h=2, h=4 and h=8 respectively, using a cubic spline, rho=" print fit(2.0), ", ", fit(4.0), ", ",fit(8.0) # C: errors rho_actual = 0.67
def test_wrapper(self): P = BarycentricInterpolator(self.xs,self.ys) assert_almost_equal(P(self.test_xs),barycentric_interpolate(self.xs,self.ys,self.test_xs))
def plot(self, fx, a=-1, b=1, n=1000): x = np.linspace(a, b, n) T = sp_interp.barycentric_interpolate(self.chebNodes(n=fx.size, a=a, b=b), fx, x) plt.plot(x, T)