def prob4(): """For n = 2^2, 2^3, ..., 2^8, calculate the error of intepolating Runge's function on [-1,1] with n points using SciPy's BarycentricInterpolator class, once with equally spaced points and once with the Chebyshev extremal points. Plot the absolute error of the interpolation with each method on a log-log plot. """ domain = np.linspace(-1, 1, 400) n_array = [2**i for i in range(2,9)] f = lambda x: 1 / (1 + 25*x**2) plt.ion() poly_error = [] cheby_error = [] for n in n_array: x = np.linspace(-1, 1, n) poly = BarycentricInterpolator(x) poly.set_yi(f(x)) poly_error.append(la.norm(f(domain) - poly(domain), ord=np.inf)) y = np.array([(1/2)*(2*np.cos(j*np.pi/n)) for j in range(n+1)]) cheby = BarycentricInterpolator(y) cheby.set_yi(f(y)) cheby_error.append(la.norm(f(domain) - cheby(domain), ord=np.inf)) plt.loglog(n_array, poly_error, label="equally spaced points", basex=2) plt.loglog(n_array, cheby_error, label="Chebyshev extremal points", basex=2) plt.legend() plt.show()
def interpolator(self, x, values): """Returns a polynomial with vector coefficients which interpolates the values at the Chebyshev points x.""" # hacking the barycentric interpolator by computing the weights in advance p = Bary([0.]) N = len(values) weights = np.ones(N) weights[0] = .5 weights[1::2] = -1 weights[-1] *= .5 p.wi = weights p.xi = x p.set_yi(values) return p
def estimate_function_for_air_data(n): """Interpolate the air quality data found in airdata.npy using Barycentric Lagrange interpolation. Plots the original data and the interpolating polynomial. Parameters: n (int): Number of interpolating points to use. """ #dataset of air quality data = np.load('airdata.npy') #chevy extrizers fx = lambda a, b, n: .5 * (a + b + (b - a) * np.cos(np.arange(n + 1) * np.pi / n)) #scaled intervals to apx chevy extremizers a, b = 0, 366 - 1 / 24 #scaled domain domain = np.linspace(0, b, 8784) #apx chevy extrema with regars to actual data (non continuous data....) points = fx(a, b, n) #mask for extrema aprx temp = np.abs(points - domain.reshape(8784, 1)) temp2 = np.argmin(temp, axis=0) #interpolating poylynomial poly = BarycentricInterpolator(domain[temp2]) poly.set_yi(data[temp2]) #plot the data #set up plot settings plt.subplot(211) plt.title("PM_2.5 hourly concentration data 2016") plt.xlabel("Hours from Jan 1") plt.ylabel("PM_2.5 level") plt.plot(data) #domain for graph # x = np.linspace(0, 8784, 8784 * 10) x = np.linspace(0, b, len(domain)) #plot the data #set up plot settings plt.subplot(212) plt.xlabel("Days from Jan 1") plt.ylabel("PM_2.5 level") plt.title("Aproximating Polynomial") #show graph plt.plot(x, poly(x)) plt.tight_layout() plt.show()
def test_barcentric_against_runges_function(): """For n = 2^2, 2^3, ..., 2^8, calculate the error of intepolating Runge's function on [-1,1] with n points using SciPy's BarycentricInterpolator class, once with equally spaced points and once with the Chebyshev extremal points. Plot the absolute error of the interpolation with each method on a log-log plot. """ #domain for graph d = np.linspace(-1, 1, 400) #iterations for testing B interp. point effect N = [2**2, 2**3, 2**4, 2**5, 2**6, 2**7, 2**8] #function to approximate f = np.vectorize(lambda x: 1 / (1 + 25 * x**2)) #to chevy, extrema ch_ext = lambda a, b, n: .5 * (a + b + (b - a) * np.cos( (np.arange(0, n) * np.pi) / n)) #evenly spaced error margins e1 = [] #cheby extram interp error margins e2 = [] for n in N: #points to interpolate pts = np.linspace(-1, 1, n) #interpolate poly = BarycentricInterpolator(pts) poly.set_yi(f(pts)) #get errror in terms of infinity norm e1.append(la.norm(f(d) - poly(d), ord=np.inf)) #points to interpolate pts = ch_ext(-1, 1, n + 1) #interpolate poly = BarycentricInterpolator(pts) poly.set_yi(f(pts)) #get errror in terms of infinity norm e2.append(la.norm(f(d) - poly(d), ord=np.inf)) #graph everything n terms of log base 10 plt.xscale('log', basex=10) plt.yscale('log', basey=10) plt.plot(N, e1, label="uniform points") plt.plot(N, e2, label="chev. extrema") #set graph labels plt.xlabel("# of interp. points") plt.ylabel("Error") plt.title("Uniform vs Cheby interp. error") plt.legend() plt.show()
def interpolator(self, x, values): """ Returns a polynomial with vector coefficients which interpolates the values at the Chebyshev points x """ # hacking the barycentric interpolator by computing the weights in advance p = Bary([0.]) N = len(values) weights = np.ones(N) weights[0] = .5 weights[1::2] = -1 weights[-1] *= .5 p.wi = weights p.xi = x p.set_yi(values) return p
def generalized_gauss(collocation_points, verbose=False): p, result1, result2 = args.degree, [], [] interp = BarycentricInterpolator(collocation_points) for n in range(p//2): filename = 'weights{}.txt'.format(n+1) with open(filename) as f: header = f.readline() x = float(header.split()[-1]) # check if quadrature is for the given collacation point assert math.isclose(x, collocation_points[n], rel_tol=fixed.exact_tol) y, w = np.loadtxt(filename, unpack=True) check_generalized(lambda f: np.sum(w*f(y)), x, verbose) I, b1, b2 = np.eye(collocation_points.size), [], [] for i in range(collocation_points.size): interp.set_yi(I[i]) b1.append(interp(y)) b2.append(interp(1-y[::-1])) result1.append(( y, w, np.array(b1) )) result2.append(( 1-y[::-1], w[::-1], np.array(b2) )) return result1 + result2[::-1]
def test_delayed(self): P = BarycentricInterpolator(self.xs) P.set_yi(self.ys) assert_almost_equal(self.true_poly(self.test_xs),P(self.test_xs))
def test_delayed(self): P = BarycentricInterpolator(self.xs) P.set_yi(self.ys) assert_almost_equal(self.true_poly(self.test_xs), P(self.test_xs))
image_step = 200 for i in np.arange(n_images * image_step): if i % image_step == 0: fig = plt.figure(figsize=(20, 16)) gs = gridspec.GridSpec(3, 3) ax0 = fig.add_subplot(gs[1:, 1:]) axh = fig.add_subplot(gs[1, 0]) axh.set_title('h') axQ_minus = fig.add_subplot(gs[0, 1]) axQ_minus.set_title('Q_minus') axT_minuse = fig.add_subplot(gs[0, 2]) axT_minuse.set_title('T_minus') axshear = fig.add_subplot(gs[2, 0]) axshear.set_title('shear') interpolator.set_yi(active_space_a) ac_space_a_plot = np.array(map(interpolator, rng)) HB_int = np.argmin( np.abs(ac_space_a_plot - 0.5 * (np.max(ac_space_a_plot) - np.min(ac_space_a_plot)))) print HB_int ax0.plot(rng, np.array(map(interpolator, rng)) / 10. + np.max(active_const_a) / 10., label='active_a') interpolator.set_yi(active_space_i) ax0.plot(rng, np.array(map(interpolator, rng)) / 10. + np.max(active_const_i) / 10., label='active_i') interpolator.set_yi(v_x)
image_step= 200 for i in np.arange(n_images*image_step): if i%image_step == 0: fig= plt.figure(figsize=(20,16)) gs= gridspec.GridSpec(3,3) ax0= fig.add_subplot(gs[1:,1:]) axh= fig.add_subplot(gs[1,0]) axh.set_title('h') axQ_minus= fig.add_subplot(gs[0,1]) axQ_minus.set_title('Q_minus') axT_minuse=fig.add_subplot(gs[0,2]) axT_minuse.set_title('T_minus') axshear= fig.add_subplot(gs[2,0]) axshear.set_title('shear') interpolator.set_yi(active_space_a) ac_space_a_plot= np.array(map(interpolator, rng)) HB_int= np.argmin(np.abs(ac_space_a_plot- 0.5*(np.max(ac_space_a_plot)-np.min(ac_space_a_plot)))) print HB_int ax0.plot(rng, np.array(map(interpolator, rng))/10.+ np.max(active_const_a)/10.,label= 'active_a') interpolator.set_yi(active_space_i) ax0.plot(rng, np.array(map(interpolator, rng))/10.+ np.max(active_const_i)/10.,label= 'active_i') interpolator.set_yi(v_x) ax0.plot(rng, np.array(map(interpolator,rng))*3., label= 'vx') interpolator.set_yi(h) h_plot=np.array(map(interpolator,rng)) avg_h_blade.append(np.sum(h_plot[HB_int:])*x_step/(rng[-1]-rng[HB_int])) axh.plot(range(len(avg_h_blade)),avg_h_blade) axh.set_xlim([0,n_images]) ax0.plot(rng, np.array(map(interpolator,rng))/5., label='h') interpolator.set_yi(Q_minus)