def test_shapes_scalarvalue_derivative(self): P = KroghInterpolator(self.xs,self.ys) n = P.n assert_array_equal(np.shape(P.derivatives(0)), (n,)) assert_array_equal(np.shape(P.derivatives(np.array(0))), (n,)) assert_array_equal(np.shape(P.derivatives([0])), (n,1)) assert_array_equal(np.shape(P.derivatives([0,1])), (n,2))
def test_wrapper(self): P = KroghInterpolator(self.xs, self.ys) ki = krogh_interpolate assert_almost_equal(P(self.test_xs), ki(self.xs, self.ys, self.test_xs)) assert_almost_equal(P.derivative(self.test_xs, 2), ki(self.xs, self.ys, self.test_xs, der=2)) assert_almost_equal(P.derivatives(self.test_xs, 2), ki(self.xs, self.ys, self.test_xs, der=[0, 1]))
def test_int_inputs(self): # Check input args are cast correctly to floats, gh-3669 x = [0, 234,468,702,936,1170,1404,2340,3744,6084,8424,13104,60000] offset_cdf = np.array([-0.95, -0.86114777, -0.8147762, -0.64072425, -0.48002351, -0.34925329, -0.26503107, -0.13148093, -0.12988833, -0.12979296, -0.12973574, -0.08582937, 0.05]) f = KroghInterpolator(x, offset_cdf) assert_allclose(abs((f(x) - offset_cdf) / f.derivative(x, 1)), 0, atol=1e-10)
def test_hermite(self): xs = [0,0,0,1,1,1,2] ys = [self.true_poly(0), self.true_poly.deriv(1)(0), self.true_poly.deriv(2)(0), self.true_poly(1), self.true_poly.deriv(1)(1), self.true_poly.deriv(2)(1), self.true_poly(2)] P = KroghInterpolator(self.xs,self.ys) assert_almost_equal(self.true_poly(self.test_xs),P(self.test_xs))
def parametres(r, interpolation): FaCO = [0.172, 0.345, 0.689, 1.03, 1.38, 2.07, 3.45, 5.17, 6.89] e = [0.19, 0.22, 0.26, 0.28, 0.30, 0.34, 0.38, 0.42, 0.44] Y = [2.30, 1.99, 1.71, 1.55, 1.45, 1.31, 1.15, 1.04, 1.00] if interpolation == "lineaire": f = interpolate.interp1d(FaCO, e) g = interpolate.interp1d(FaCO, Y) if interpolation == "cubique": f = KroghInterpolator(FaCO, e) g = KroghInterpolator(FaCO, Y) if interpolation == "cubique": f = interpolate.interp1d(FaCO, e, kind='cubic') g = interpolate.interp1d(FaCO, Y, kind='cubic') e = f(r) y = g(r) X = 1 - e * y return float(e), float(X), float(y)
def cutoff(x, a=1, b=2, radius=0.2, L=3, deg=3): a0 = a b0 = b a1 = a0 + radius b1 = b0 - radius assert a1 <= b1, 'a + radius must be less than b - radius' pts1 = np.concatenate((a0 * np.ones(deg), a1 * np.ones(deg))) vals1 = np.zeros(2 * deg) vals1[deg] = 1 krogh1 = KroghInterpolator(pts1, vals1) pts2 = np.concatenate((b1 * np.ones(deg), b0 * np.ones(deg))) vals2 = np.zeros(2 * deg) vals2[0] = 1 krogh2 = KroghInterpolator(pts2, vals2) return np.piecewise(x, [ np.logical_and(x > a0, x < a1), np.logical_and(x >= a1, x <= b1), np.logical_and(x > b1, x < b0) ], [krogh1, 1, krogh2, 0])
def _poly(xx, yy): """ Uses polynomial interpolation to find a function matching a dataset. Args: xx (1darray): X-coordinates sorted in increasing order. yy (1darray): Corresponding y-coordinates. Returns: intfunc (PPoly): The interpolated function. """ intfunc = KroghInterpolator(xx, yy) return intfunc
def kroghInterpolation(): sample_rate, sample = wavfile.read('songs/hakuna_matata.wav') sample = sample[5000000:5000100] sample_rateBAD, sampleBAD = wavfile.read( 'songs/bad_songs/not_good_song.wav') sampleBAD = sampleBAD[5000000:5000100] BadSample = sample.copy() dz.theEvilMethod(BadSample, 0.5) matches = recognize.cheat(sample, BadSample) x, y = utils.tovalidxy(BadSample, matches) f = KroghInterpolator(x, y) utils.repair(BadSample, matches, f) IwannaSee(sample, BadSample, sampleBAD)
def calculate_and_save_results(inputpath, outputpath): """ Docstring """ rd.load_data(inputpath) mass = rd.particle_mass() x_min = rd.x_minimum() x_max = rd.x_maximum() npoint = rd.n_point() fval = rd.first_eigenvalue() lval = rd.last_eigenvalue() inter_type = rd.interpolation_type() x_pot = rd.x_potential() y_pot = rd.y_potential() delta = (x_max-x_min)/npoint const_a = 1/(mass*delta**2) x_axis = np.linspace(x_min, x_max, npoint) #interpolating y_pot_inter = [] if inter_type == "polynomial": y_pot_inter = KroghInterpolator(x_pot, y_pot) else: y_pot_inter = interp1d(x_pot, y_pot, kind=inter_type) #calculating expected_x = np.array([]) uncertainties = np.array([]) energies = np.array([]) norm_eigenvecs = np.array([]) maindiag = y_pot_inter(x_axis)+const_a seconddiag = np.full(npoint-1, -1/2*const_a) selectrange = (fval-1, lval-1) ev = eigh_tridiagonal(maindiag, seconddiag, select="i", select_range=selectrange) (energies, eigenvecs) = ev norm_eigenvecs = np.array([normalize(eigenvec, delta) for eigenvec in eigenvecs.T]) expected_x = np.array([exp_x(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs]) uncertaintylist = [uncertainty(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs] uncertainties = np.array(uncertaintylist) rd.save_xyformat(outputpath + "/potential.dat", x_axis, y_pot_inter(x_axis)) rd.save_nxyformat(outputpath + "/wavefuncs.dat", x_axis, norm_eigenvecs.T) rd.save_xyformat(outputpath + "/energies.dat", energies, ["" for _ in energies]) rd.save_xyformat(outputpath + "/expvalues.dat", expected_x, uncertainties)
def data_to_function(self): ''' Uses the KroghInterpolator to make a function from our data and uses that function to predict the prices at the wanted dates. returns: wanted dates (self.intra_x_values) and their associated predicted prices (self.intra_y_values) ''' print(self.x_values) print(self.y_values) poly_func = KroghInterpolator(self.x_values, self.y_values) self.creating_wanted_days(self.n_days) #self.intra_x_values= [1477492378020,1477492378030] #self.intra_x_values = self.intra_x_values[:-1] self.intra_x_values = np.asarray(self.intra_x_values) #print(self.intra_x_values) print(self.intra_x_values) self.intra_y_values = poly_func.__call__(self.intra_x_values) print(self.intra_y_values) return self.intra_x_values, self.intra_y_values
def test_shapes_scalarvalue(self): P = KroghInterpolator(self.xs, self.ys) assert_array_equal(np.shape(P(0)), ()) assert_array_equal(np.shape(P(np.array(0))), ()) assert_array_equal(np.shape(P([0])), (1, )) assert_array_equal(np.shape(P([0, 1])), (2, ))
def test_hermite(self): P = KroghInterpolator(self.xs, self.ys) assert_almost_equal(self.true_poly(self.test_xs), P(self.test_xs))
def test_empty(self): P = KroghInterpolator(self.xs, self.ys) assert_array_equal(P([]), [])
def test_derivative(self): P = KroghInterpolator(self.xs, self.ys) m = 10 r = P.derivatives(self.test_xs, m) for i in range(m): assert_almost_equal(P.derivative(self.test_xs, i), r[i])
def test_high_derivative(self): P = KroghInterpolator(self.xs, self.ys) for i in range(len(self.xs), 2 * len(self.xs)): assert_almost_equal(P.derivative(self.test_xs, i), np.zeros(len(self.test_xs)))
def test_shapes_vectorvalue_derivative(self): P = KroghInterpolator(self.xs, np.outer(self.ys, np.arange(3))) n = P.n assert_array_equal(np.shape(P.derivatives(0)), (n, 3)) assert_array_equal(np.shape(P.derivatives([0])), (n, 1, 3)) assert_array_equal(np.shape(P.derivatives([0, 1])), (n, 2, 3))
def interpolate(x0, x1, m0, m1, t0, t1): x = np.repeat([t0, t1], 2) y = np.ravel(np.dstack(([x0, x1], [m0, m1]))) return KroghInterpolator(x, y)
def main(): parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('--Tmin', type=float, default=.050, help='minimum temperature') parser.add_argument('--Ta', type=float, default=.165, help='connection range minimum temperature') parser.add_argument('--Tb', type=float, default=.200, help='connection range maximum temperature') parser.add_argument('--Tmax', type=float, default=.500, help='maximum temperature') parser.add_argument('--nsteps', type=int, default=10**5, help='number of energy density steps') parser.add_argument('--species', choices=['all', 'urqmd', 'id'], default='urqmd', help='HRG species') parser.add_argument('--res-width-off', action='store_false', dest='res_width', help='do not account for finite width of resonances') parser.add_argument('--plot', nargs='?', metavar='FILE', const='<show>', default=False, help='plot EoS instead of printing table') parser.add_argument('--music_output_format', action='store_true', dest='music_output_format', default=False, help='EOS format expected by MUSIC') parser.add_argument('--write-bin', metavar='FILE', help='write binary file instead of printing table') args = parser.parse_args() hrg_kwargs = dict(species=args.species, res_width=args.res_width) # split full temperature range into three parts: # low-T (l): Tmin < T < Ta (HRG) # mid-T (m): Ta < T < Tb (connection) # high-T (h): Tb < T < Tmax (lattice) # number of extra temperature points below Tmin and above Tmax # (helps cubic interpolation) nextrapts = 2 # compute low-T (HRG) trace anomaly Tl = T_points(args.Tmin, args.Ta, 200, extra_low=nextrapts) e3p_T4_l = HRGEOS(Tl, **hrg_kwargs).e3p_T4() # compute mid-T (connection) using an interpolating polynomial that # matches the function values and first several derivatives at the # connection endpoints (Ta, Tb) nd = 5 # use Krogh interpolation near the endpoints to estimate derivatives def derivatives(f, T0, dT=.001): # evaluate function at Chebyshev zeros as suggested by docs T = T0 + dT * np.cos(np.linspace(0, np.pi, nd)) return KroghInterpolator(T, f(T)).derivatives(T0) # use another Krogh interpolation for the connection polynomial # skip (Ta, Tb) endpoints in Tm since they are already in (Tl, Th) Tm = T_points(args.Ta, args.Tb, 100, extra_low=-1, extra_high=-1) e3p_T4_m = KroghInterpolator( nd * [args.Ta] + nd * [args.Tb], np.concatenate([ derivatives(lambda T: HRGEOS(T, **hrg_kwargs).e3p_T4(), args.Ta), derivatives(e3p_T4_lattice, args.Tb) ]))(Tm) # compute high-T part (lattice) Th = T_points(args.Tb, args.Tmax, 1000, extra_high=nextrapts) e3p_T4_h = e3p_T4_lattice(Th) # join temperature ranges together T = np.concatenate([Tl, Tm, Th]) e3p_T4 = np.concatenate([e3p_T4_l, e3p_T4_m, e3p_T4_h]) # pressure is integral of trace anomaly over temperature starting from some # reference temperature, Eq. (12) in HotQCD paper: # p/T^4(T) = p/T^4(T_0) + \int_{T_0}^T dT (e - 3p)/T^5 delta_p_T4_spline = CubicSpline(T, e3p_T4 / T).antiderivative() p_T4_0 = HRGEOS(T[:1], **hrg_kwargs).p_T4()[0] def compute_p_T4(T): p_T4 = delta_p_T4_spline(T) p_T4 += p_T4_0 return p_T4 p_T4 = compute_p_T4(T) e_T4 = e3p_T4 + 3 * p_T4 if args.plot: plot(T, e3p_T4, p_T4, e_T4, args, hrg_kwargs) return # energy density at original temperature points e_orig = e_T4 * T**4 / HBARC**3 # compute thermodynamic quantities at evenly-spaced energy density points # as required by osu-hydro e = np.linspace(e_orig[nextrapts], e_orig[-nextrapts - 1], args.nsteps) T = CubicSpline(e_orig, T)(e) p = compute_p_T4(T) * T**4 / HBARC**3 s = (e + p) / T if args.write_bin: with open(args.write_bin, 'wb') as f: if (args.music_output_format): for x in zip(e, p, s, T): f.write(x[0]) f.write(x[1]) f.write(x[2]) f.write(x[3]) else: for x in [e[0], e[-1], p, s, T]: f.write(x.tobytes()) else: # output table fmt = 4 * '{:24.16e}' for row in zip(e, p, s, T): print(fmt.format(*row))
def derivatives(f, T0, dT=.001): # evaluate function at Chebyshev zeros as suggested by docs T = T0 + dT * np.cos(np.linspace(0, np.pi, nd)) return KroghInterpolator(T, f(T)).derivatives(T0)
def test_high_degree_warning(self): with pytest.warns(UserWarning, match="40 degrees provided,"): KroghInterpolator(np.arange(40), np.ones(40))
def calculate_and_save_results(inputpath, outputpath): """ this function does three things: -interpolating the given points of the potential defined by the user -solving the schrodinger equation and calculating the eigenstates, eigenvalues, expected values and uncertainties -saving the results in .dat files :type inputpath: string :param inputpath: path of the schrodinger.inp file containing the input information :type outputpath: string :param outputpath: path of the directory the .dat files will be stored in """ rd.load_data(inputpath) mass = rd.particle_mass() x_min = rd.x_minimum() x_max = rd.x_maximum() npoint = rd.n_point() fval = rd.first_eigenvalue() lval = rd.last_eigenvalue() inter_type = rd.interpolation_type() x_pot = rd.x_potential() y_pot = rd.y_potential() delta = (x_max - x_min) / npoint const_a = 1 / (mass * delta**2) x_axis = np.linspace(x_min, x_max, npoint) y_pot_inter = [] expected_x = np.array([]) uncertainties = np.array([]) energies = np.array([]) norm_eigenvecs = np.array([]) #interpolating if inter_type == "polynomial": y_pot_inter = KroghInterpolator(x_pot, y_pot) else: y_pot_inter = interp1d(x_pot, y_pot, kind=inter_type) #calculating maindiag = y_pot_inter(x_axis) + const_a seconddiag = np.full(npoint - 1, -1 / 2 * const_a) selectrange = (fval - 1, lval - 1) ev = eigh_tridiagonal(maindiag, seconddiag, select="i", select_range=selectrange) (energies, eigenvecs) = ev norm_eigenvecs = np.array( [normalize(eigenvec, delta) for eigenvec in eigenvecs.T]) expected_x = np.array( [exp_x(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs]) uncertaintylist = [ uncertainty(eigenvec, delta, x_axis) for eigenvec in norm_eigenvecs ] uncertainties = np.array(uncertaintylist) #saving if not outputpath.endswith("/"): outputpath = outputpath + "/" rd.save_xyformat(outputpath + "potential.dat", x_axis, y_pot_inter(x_axis)) rd.save_nxyformat(outputpath + "wavefuncs.dat", x_axis, norm_eigenvecs.T) rd.save_xyformat(outputpath + "energies.dat", energies, ["" for _ in energies]) rd.save_xyformat(outputpath + "expvalues.dat", expected_x, uncertainties) print("The results have been saved succesfully into the folder \"" + outputpath + "\".")
# 埃尔米特插值 from scipy.interpolate import KroghInterpolator import numpy as np import matplotlib.pyplot as plt def f(x): return x**3 + 1 xs = np.linspace(-5, 5, 100) nodes = np.array([0, 1, 2, 3]) xi = np.array([0, 1, 2, 3]) yi = np.array([1, 2, 9, 28]) interpolant = KroghInterpolator(xi, yi) plt.figure() plt.subplot(121) plt.plot(xs, interpolant(xs), "b--", label="Hermite interpolation") plt.plot(nodes, f(nodes), "ro", label="nodes") # 显示图中的标签 plt.legend(loc=9) # 设定坐标上下限 plt.xlim(-10.5, 10.5) plt.title("$f(x) = x^3 + 1$") # 1行 2列 plt.subplot(122) plt.plot(xs, f(xs), "g--", label="original") plt.plot(xi, f(xi), "ro", label="nodes") plt.legend(loc=9)
plt.plot(FaCO, e, 'o', x, f(x), '-') #courbe (FaCO,e) et (x,f(x)) plt.xlabel('FaCO') #nomme l'axe des x puis apres y plt.ylabel('e') plt.title('interpolation_lineaire,e=f(FaCO)') #on nomme le graphique plt.show() #on affiche g = interpolate.interp1d(FaCO, Y) x = np.linspace(0.172, 6.89, 100) y = g(x) plt.plot(FaCO, Y, 'o', x, g(x), '-') plt.xlabel('Y') plt.ylabel('e') plt.title('interpolation_lineaire,Y=f(Faco)') plt.show() f = KroghInterpolator(FaCO, e) #interpolation polynomiale x = np.linspace(0.172, 6.89, 100) y = f(x) plt.plot(FaCO, e, 'o', x, f(x), '-') plt.xlabel('FaCO') plt.ylabel('e') plt.title('interpolation_polynomiale,e=f(FaCO)') plt.show() g = KroghInterpolator(FaCO, Y) x = np.linspace(0.172, 6.89, 100) y = g(x) plt.plot(FaCO, Y, 'o', x, g(x), '-') plt.xlabel('Y') plt.ylabel('e') plt.title('interpolation_polynomiale,Y=f(Faco)')
def main(): parser = argparse.ArgumentParser( description=__doc__, formatter_class=argparse.ArgumentDefaultsHelpFormatter ) parser.add_argument( '--Tmin', type=float, default=.050, help='minimum temperature' ) parser.add_argument( '--Ta', type=float, default=.165, help='connection range minimum temperature' ) parser.add_argument( '--Tb', type=float, default=.200, help='connection range maximum temperature' ) parser.add_argument( '--Tmax', type=float, default=.500, help='maximum temperature' ) parser.add_argument( '--nsteps', type=int, default=10**5, help='number of energy density steps' ) parser.add_argument( '--species', choices=['all', 'urqmd', 'id'], default='urqmd', help='HRG species' ) parser.add_argument( '--res-width-off', action='store_false', dest='res_width', help='do not account for finite width of resonances' ) parser.add_argument( '--plot', nargs='?', metavar='FILE', const='<show>', default=False, help='plot EoS instead of printing table' ) parser.add_argument( '--write-bin', metavar='FILE', help='write binary file instead of printing table' ) args = parser.parse_args() hrg_kwargs = dict(species=args.species, res_width=args.res_width) # split full temperature range into three parts: # low-T (l): Tmin < T < Ta (HRG) # mid-T (m): Ta < T < Tb (connection) # high-T (h): Tb < T < Tmax (lattice) # number of extra temperature points below Tmin and above Tmax # (helps cubic interpolation) nextrapts = 2 # compute low-T (HRG) trace anomaly Tl = T_points(args.Tmin, args.Ta, 200, extra_low=nextrapts) e3p_T4_l = HRGEOS(Tl, **hrg_kwargs).e3p_T4() # compute mid-T (connection) using an interpolating polynomial that # matches the function values and first several derivatives at the # connection endpoints (Ta, Tb) nd = 5 # use Krogh interpolation near the endpoints to estimate derivatives def derivatives(f, T0, dT=.001): # evaluate function at Chebyshev zeros as suggested by docs T = T0 + dT*np.cos(np.linspace(0, np.pi, nd)) return KroghInterpolator(T, f(T)).derivatives(T0) # use another Krogh interpolation for the connection polynomial # skip (Ta, Tb) endpoints in Tm since they are already in (Tl, Th) Tm = T_points(args.Ta, args.Tb, 100, extra_low=-1, extra_high=-1) e3p_T4_m = KroghInterpolator( nd*[args.Ta] + nd*[args.Tb], np.concatenate([ derivatives(lambda T: HRGEOS(T, **hrg_kwargs).e3p_T4(), args.Ta), derivatives(e3p_T4_lattice, args.Tb) ]) )(Tm) # compute high-T part (lattice) Th = T_points(args.Tb, args.Tmax, 1000, extra_high=nextrapts) e3p_T4_h = e3p_T4_lattice(Th) # join temperature ranges together T = np.concatenate([Tl, Tm, Th]) e3p_T4 = np.concatenate([e3p_T4_l, e3p_T4_m, e3p_T4_h]) # pressure is integral of trace anomaly over temperature starting from some # reference temperature, Eq. (12) in HotQCD paper: # p/T^4(T) = p/T^4(T_0) + \int_{T_0}^T dT (e - 3p)/T^5 delta_p_T4_spline = CubicSpline(T, e3p_T4/T).antiderivative() p_T4_0 = HRGEOS(T[:1], **hrg_kwargs).p_T4()[0] def compute_p_T4(T): p_T4 = delta_p_T4_spline(T) p_T4 += p_T4_0 return p_T4 p_T4 = compute_p_T4(T) e_T4 = e3p_T4 + 3*p_T4 # energy density at original temperature points e_orig = e_T4 * T**4 / HBARC**3 # compute thermodynamic quantities at evenly-spaced energy density points # as required by osu-hydro e = np.linspace(e_orig[nextrapts], e_orig[-nextrapts - 1], args.nsteps) T = CubicSpline(e_orig, T)(e) p = compute_p_T4(T) * T**4 / HBARC**3 s = (e + p)/T Tc = 0.270 tlat = Tc*np.array([0.7, 0.74, 0.78, 0.82, 0.86, 0.9, 0.94, 0.98, 1, 1.02, 1.06, 1.10, 1.14, 1.18, 1.22, 1.26, 1.30, 1.34, 1.38, 1.42, 1.46, 1.5, 2, 2.5, 3, 3.5, 4.0, 4.5, 5, 6, 7, 8, 9, 10, 20, 30, 40, 50, 60, 80, 100, 200, 300, 400, 500, 600, 800, 1000]) Ilat = np.array([.0104, .0162, .0232, .0318, .0433, .0594, .0859, .1433, 1.0008, 2.078, 2.4309, 2.4837, 2.4309, 2.3426, 2.2342, 2.1145, 1.998, 1.8867, 1.7809, 1.6810, 1.5872, 1.4995, 0.8038, 0.5057, 0.3589, 0.2736, 0.2207, 0.1855, 0.1606, 0.1266, 0.1050, 0.0903, 0.0798, 0.0720, 0.0375, 0.0265, 0.0216, 0.0191, 0.0174, 0.0154, 0.0142, 0.0112, 0.01, 0.0091, 0.0085, 0.0080, 0.0073, 0.0068]) plat = np.array([0.0015, 0.0023, 0.0033, 0.0046, 0.0064, 0.0087, 0.0118, 0.0164, 0.0222, 0.0571, 0.1455, 0.237, 0.325, 0.4074, 0.4837, 0.5539, 0.6181, 0.677, 0.7309, 0.7804, 0.8258, 0.8675, 1.189, 1.3319, 1.4098, 1.4582, 1.491, 1.5149, 1.533, 1.5591, 1.5768, 1.5898, 1.5998, 1.6078, 1.6444, 1.6572, 1.6641, 1.6686, 1.672, 1.6767, 1.68, 1.6887, 1.693, 1.6958, 1.6977, 1.6992, 1.7014, 1.703]) e3p_T4_gluon = CubicSpline(tlat,Ilat) delta_p_T4_spline_gluon = CubicSpline(tlat, Ilat/tlat).antiderivative() p_T4_0_gluon = HRGEOS(tlat[:1], **hrg_kwargs).p_T4()[0] def compute_p_T4_gluon(T): p_T4 = delta_p_T4_spline_gluon(T) p_T4 += p_T4_0_gluon return p_T4 p_T4_gluon = compute_p_T4_gluon(tlat) e_T4_gluon = Ilat + 3*plat # energy density at original temperature points e_orig_gluon = e_T4_gluon * tlat**4 / HBARC**3 # compute thermodynamic quantities at evenly-spaced energy density points # as required by osu-hydro e_gluon = np.linspace(e_orig_gluon[nextrapts], e_orig_gluon[-nextrapts - 1], args.nsteps) T_gluon = CubicSpline(e_orig_gluon, tlat)(e) p_gluon = compute_p_T4_gluon(T) * T_gluon**4 / HBARC**3 s_gluon = (e_gluon + p_gluon)/T_gluon plot(T, e3p_T4, p_T4, e_T4, T_gluon, e3p_T4_gluon, p_T4_gluon, e_T4_gluon, args, hrg_kwargs) return
def test_shapes_vectorvalue(self): P = KroghInterpolator(self.xs, np.outer(self.ys, np.arange(3))) assert_array_equal(np.shape(P(0)), (3, )) assert_array_equal(np.shape(P([0])), (1, 3)) assert_array_equal(np.shape(P([0, 1])), (2, 3))
def test_scalar(self): P = KroghInterpolator(self.xs, self.ys) assert_almost_equal(self.true_poly(7), P(7)) assert_almost_equal(self.true_poly(np.array(7)), P(np.array(7)))
def test_shapes_1d_vectorvalue(self): P = KroghInterpolator(self.xs, np.outer(self.ys, [1])) assert_array_equal(np.shape(P(0)), (1, )) assert_array_equal(np.shape(P([0])), (1, 1)) assert_array_equal(np.shape(P([0, 1])), (2, 1))
def test_low_derivatives(self): P = KroghInterpolator(self.xs, self.ys) D = P.derivatives(self.test_xs, len(self.xs) + 2) for i in range(D.shape[0]): assert_almost_equal(self.true_poly.deriv(i)(self.test_xs), D[i])
def krogh_deriv(x, y, axis=0): return KroghInterpolator(x, y, axis).derivative
from scipy.interpolate import KroghInterpolator #from format_data import Formatter import matplotlib.pyplot as plt import time import numpy as np x_values = [1,2,3,4,5] y_values = [6,7,8,9,10] intra_x_values = [6,7,8] poly_func = KroghInterpolator(x_values,y_values) intra_x_values = np.asarray(intra_x_values) intra_y_values = poly_func.__call__(intra_x_values) print(intra_y_values)