def zcyl(n, Bi): try: Bi.ito("") except: pass if n == 1: lb = 0 ub = 2.4 return ridder(fcyl, lb, ub, args=(Bi, )) else: lb = 0.005 + (n - 1) * np.pi ub = 2.35 + (n - 1) * np.pi return ridder(fcyl, lb, ub, args=(Bi, ))
def zwal(n, Bi): try: Bi.ito("") except: pass if n == 1: lb = 0 ub = (2 * n - 1) * np.pi / 2 return ridder(fwal, lb, ub, args=(Bi, )) else: lb = (2 * n - 1) * np.pi / 2 - np.pi * 0.9999 ub = (2 * n - 1) * np.pi / 2 * 0.9999 return ridder(fwal, lb, ub, args=(Bi, ))
def pressurizingSysMass(oxVol, methVol, disp=False): mtHe = [] mHe = [] vOut = (4 / 3) * np.pi * (d / 2)**3 def volumeHe(pressHe): return (4 / 3) * np.pi * ((d / 2) * (1 - pressHe * 1.5 / (2 * s_al)))**3 def hePressure(press, ind): return pr[ind] * ((oxVol[ind] + methVol[ind]) + volumeHe(press)) - press * volumeHe(press) for i in range(0, len(pc)): pHe = opt.ridder(hePressure, 10000, 100000000, args=i) vHe = volumeHe(pHe) mHe.append((vHe * pHe / (rHe * 300)) * 4) mtHe.append((vOut - vHe) * rho_al) if (disp): parameters.extend([ "He Volume(l)", "He Pressure (MPA)", "He Tank Mass(kg)", "He Mass" ]) values.extend([vHe, pHe, mtHe, mHe]) return mtHe + mHe
def has_solution(interpolated_vec, t_last, t_current, alpha_obst): try: t = ridder(lambda t: interpolated_vec(t)[0][0] - alpha_obst, t_last, t_current) return True, t except: return False, 0
def find_friction(self): # Finds zeroes, X - friction velocity, Z - height, Karman's constant = 0.4 z = 10 f = lambda x: x / 0.4 * np.log(z / (0.684 / x + 428e-7 * x**2 - 443e-4)) root = optimize.ridder(f, 1e-8, 80) return root
def zsph(n, Bi): try: Bi.ito("") except: pass lb = n * np.pi - 0.9999 * np.pi ub = n * np.pi * 0.9999 return ridder(fsph, lb, ub, args=(Bi, ))
def bsmRidder(self, a=-0.1, b=3): if self.f(a) * self.f(b) > 0: print('No root! Change the lower and upper value!\n') return self.sigma, np.nan for i in range(self.maxIter): if self.f(a) * self.f(b) < 0: return ridder(self.f, a, b, args=(), xtol=2e-12, rtol=8.8817841970012523e-16, maxiter=100, full_output=True, disp=True)
def calcModesLoaded(self, f0, n_vec, N, C_j, C_0, C_s, E_c, E_j): # eq_even = lambda omega_l: -1020.0*np.sqrt(2)*C_s*omega_l*np.sqrt(E_c/(E_j*(-np.cos(np.pi*n/N) + 1)*(C_0/(2*C_j) - np.cos(np.pi*n/N) + 1))) - np.tan(np.pi*n*omega_l/(2*f0*np.sqrt((-np.cos(np.pi*n/N) + 1)/(C_0/(2*C_j) - np.cos(np.pi*n/N) + 1)))) # eq_odd = lambda omega_l: -np.tan(np.pi*n*omega_l/(2*f0*np.sqrt((-np.cos(np.pi*n/N) + 1)/(C_0/(2*C_j) - np.cos(np.pi*n/N) + 1)))) + 0.000490196078431373*np.sqrt(2)/(C_s*omega_l*np.sqrt(E_c/(E_j*(-np.cos(np.pi*n/N) + 1)*(C_0/(2*C_j) - np.cos(np.pi*n/N) + 1)))) sol = np.array([]) eps = 1e2 for n in n_vec: if n % 2 == 0: # even numbers # eq = lambda w_l_num: eq_even_num(nn,N_num,C0_num,Cj_num,Cs_num,w0_num,Ec_num,Ej_num,w_l_num) eq = lambda omega_l: -1020.0 * np.sqrt(2) * C_s * omega_l * np.sqrt( E_c / (E_j * (-np.cos(np.pi * n / N) + 1) * (C_0 / (2 * C_j) - np.cos(np.pi * n / N) + 1)) ) - np.tan( np.pi * n * omega_l / (2 * f0 * np.sqrt((-np.cos(np.pi * n / N) + 1) / (C_0 / (2 * C_j) - np.cos(np.pi * n / N) + 1))) ) sol = np.append( sol, opt.ridder(eq, self.unloadedModes[n - 1] * (1 - 1 / n) + eps, self.unloadedModes[n - 1] - eps) ) else: # eq = lambda w_l_num: eq_odd_num(nn,N_num,C0_num,Cj_num,Cs_num,w0_num,Ec_num,Ej_num,w_l_num) eq = lambda omega_l: -np.tan( np.pi * n * omega_l / (2 * f0 * np.sqrt((-np.cos(np.pi * n / N) + 1) / (C_0 / (2 * C_j) - np.cos(np.pi * n / N) + 1))) ) + 0.000490196078431373 * np.sqrt(2) / ( C_s * omega_l * np.sqrt( E_c / (E_j * (-np.cos(np.pi * n / N) + 1) * (C_0 / (2 * C_j) - np.cos(np.pi * n / N) + 1)) ) ) if n == 1: sol = np.append(sol, opt.ridder(eq, eps, self.unloadedModes[n - 1] - eps)) else: sol = np.append( sol, opt.ridder(eq, self.unloadedModes[n - 1] * (1 - 2 / n) + eps, self.unloadedModes[n - 1] - eps), ) return sol
def make_exponential_levels(dz_min, top, n_levels): level_rate = ridder( exponential_levels_error, 1.000000000000001, 2.0, args=(dz_min, top, n_levels) ) level_list = [0.0] for level in range(1, n_levels): level_list = level_list + [ dz_min * ((1.0 - level_rate ** level) / (1.0 - level_rate)) ] level_list[n_levels - 1] = top return np.array(level_list)
def flash_PVF_zs(self, P, VF, zs): try: # In some caases, will find a false root - resort to iterations which # are always between Pdew and Pbubble if this happens T = brenth(self._P_VF_err_2, min(self.Tms), min(self.Tcs), args=(P, VF, zs), maxiter=500) V_over_F, xs, ys = self._flash_sequential_substitution_TP(T=T, P=P, zs=zs) assert abs(V_over_F-VF) < 1E-6 except: T = ridder(self._P_VF_err, min(self.Tms), min(self.Tcs), args=(P, VF, zs)) V_over_F, xs, ys = self._flash_sequential_substitution_TP(T=T, P=P, zs=zs) return 'l/g', xs, ys, V_over_F, T
def __init__(self, unfold: lib.Unfolding, alpha): assert len(unfold.omegas) == 1 assert alpha is None or len(alpha) == 1 # ---- self.aMax = alpha[0] self.unfold = unfold aMax = alpha[0] pMax = unfold.alpha_prob(alpha) # Calculate credible intervals for α self.ci1Sigma = ( ridder(lambda x: unfold.alpha_prob([x]) - pMax + 0.5, aMax / 10, aMax), ridder(lambda x: unfold.alpha_prob([x]) - pMax + 0.5, aMax, aMax * 10), ) self.ci2Sigma = ( ridder(lambda x: unfold.alpha_prob([x]) - pMax + 2, aMax / 10, aMax), ridder(lambda x: unfold.alpha_prob([x]) - pMax + 2, aMax, aMax * 10), )
def test_point_defect_state(self): ms = self.init_solver() ms.geometry_lattice = mp.Lattice(size=mp.Vector3(5, 5)) ms.geometry = [mp.Cylinder(0.2, material=mp.Medium(epsilon=12))] ms.geometry = mp.geometric_objects_lattice_duplicates( ms.geometry_lattice, ms.geometry) ms.geometry.append(mp.Cylinder(0.2, material=mp.air)) ms.resolution = 16 ms.k_points = [mp.Vector3(0.5, 0.5)] ms.num_bands = 50 ms.run_tm() mpb.fix_efield_phase(ms, 25) mpb.output_efield_z(ms, 25) mpb.fix_dfield_phase(ms, 25) ms.get_dfield(25) ms.compute_field_energy() c = mp.Cylinder(1.0, material=mp.air) e = ms.compute_energy_in_objects([c]) self.assertAlmostEqual(0.6227482574427817, e, places=3) ms.num_bands = 1 ms.target_freq = (0.2812 + 0.4174) / 2 ms.tolerance = 1e-8 ms.run_tm() expected_brd = [ ((0.37730041222979477, mp.Vector3(0.5, 0.5, 0.0)), (0.37730041222979477, mp.Vector3(0.5, 0.5, 0.0))), ] self.check_band_range_data(expected_brd, ms.band_range_data) old_geometry = ms.geometry # save the 5x5 grid with a missing rod def rootfun(eps): ms.geometry = old_geometry + [ mp.Cylinder(0.2, material=mp.Medium(epsilon=eps)) ] ms.run_tm() return ms.get_freqs()[0] - 0.314159 rooteps = ridder(rootfun, 1, 12) rootval = rootfun(rooteps) self.assertAlmostEqual(5.288830111797463, rooteps, places=3) self.assertAlmostEqual(9.300716530269426e-9, rootval, places=3)
def wavenumber(T, h): '''Returns wavelength given a period, depth of water, and two bounds on k. It should be noted that the bounds as a function of k less the angular frequency squared should be of different sign. The bounds are written inside this function and should be changed later.''' k_bound1 = 0 k_bound2 = 20 def _dispersion_k(k): return (g.magnitude * k * np.tanh(k * h) - (((2 * np.pi) / T))**2) root = optimize.ridder(_dispersion_k, k_bound1, k_bound2) return (root)
def bsmRidder(self, a=1e-15, b=2): for i in range(self.maxIter): if self.f(a) * self.f(b) < 0: return ridder(self.f, a, b, args=(), xtol=2e-12, rtol=8.8817841970012523e-16, maxiter=100, full_output=False, disp=True) else: b -= 0.1
def choose_r(G=None): ''' Find value of r that sets difference to zero between fraction of distribution on neighbors and non-neighbors to zero. Derived from Hotnet2. @parameter G - a graph @return G - a graph ''' A = nx.to_numpy_array(G) r = ridder(lambda r: difference(A, r), a=0.01, b=0.99, xtol=0.001) G.graph['r'] = r return G
def find_ztran(zlist, klist, xps): ztran = [] for k in range(len(klist)): this_xps = xps[:, k] xps_fn_z = interp1d(zlist, this_xps) try: sol = ridder(xps_fn_z, 9, 12.3) except: sol = np.nan this_ztran = float(sol) ztran.append(this_ztran) return klist, np.array(ztran)
def MMMallowTheta(ranks_cplt, median): """ :return: the MLE theta parameter in Mallows distribution """ Nsamp = len(ranks_cplt) Nclass = len(ranks_cplt[0]) distances = [discordant(ranks_cplt[i], median) for i in range(Nsamp)] distances = np.array(distances, dtype=np.float16) dev = np.mean(distances) try: theta = ridder(MallowsThetaDev, 1e-5, 1e+5, args=(dev, Nclass)) return theta except ValueError, e: print "!!!Not well chosen median" raise e
def calc_u_g(feh, g_r, u_g_range = [0.7, 1.7]): """ Use relation from Bond et al 2010 to compute the expected u-g color given stellar metalicity and g-r color. # g-r in range 0.25 to 0.58 """ if np.size(feh) > 1: result = [] for metal, color in zip(feh, g_r): func = sdss_metal(metal, color) try: u_g = ridder(func, u_g_range[0], u_g_range[1]) except: u_g = np.nan result.append(u_g) result = np.array(result) else: func = sdss_metal(feh, g_r) try: result = ridder(func, u_g_range[0], u_g_range[1]) except: result = np.nan return result
def _make_exponential_levels(dz_min, z_top, n_levels): """ Makes exponentially distributed levels """ if dz_min is None: raise Exception("For exponential levels `dz_min` must be a float") level_rate = ridder( exponential_levels_error, 1.000000000000001, 2.0, args=(dz_min, z_top, n_levels) ) level_list = [0.0] for level in range(1, n_levels): level_list = level_list + [ dz_min * ((1.0 - level_rate**level) / (1.0 - level_rate)) ] level_list[n_levels - 1] = z_top return np.array(level_list)
def identify_damping(self, w, verb=False): """ Identify damping at circular frequency `w` (rad/s) """ M = np.abs(self.morlet_integrate(self.n1, w)) /\ np.abs(self.morlet_integrate(self.n2, w)) if self._root_finding == "close": return self.n1 * self.n2 / 2 / np.pi /\ np.sqrt(self.k * self.k * (self.n2 *\ self.n2 - self.n1 * self.n1)) *\ np.sqrt(np.log(np.sqrt(self.n1 / self.n2) * M)) else: # eq (19): eqn = lambda x: np.exp(4 * np.pi**2 * self.k**2\ * x**2 * (self.n2**2 -\ self.n1**2) / self.n1**2 / self.n2**2) *\ np.sqrt(self.n2 / self.n1) *\ (erf(2 * np.pi * self.k * x / self.n1 +\ self.n1 / 4)\ -erf(2 * np.pi * self.k * x / self.n1 -\ self.n1 / 4)) /\ (erf(2 * np.pi * self.k * x / self.n2 +\ self.n2 / 4)\ -erf(2 * np.pi * self.k * x / self.n2 -\ self.n2 / 4)) - M try: # dmp, r = newton(eqn, self.x0, maxiter=10, full_output=True, disp=False) dmp, r = ridder(eqn, self.x0[0], self.x0[1], xtol=1e-6, maxiter=10,\ full_output=True, disp=False) if not r.converged: dmp = np.NaN if verb: print( 'Newton-Ralphson: maximum iterations limit reached!' ) except RuntimeWarning: if verb: print('Newton-Ralphson raised Warning.') except ValueError: dmp = np.NaN return dmp
def find_steady_state(self, a, b, method='brentq', **kwargs): """ Compute the equilibrium value of capital stock (per unit effective labor). Parameters ---------- a : float One end of the bracketing interval [a,b]. b : float The other end of the bracketing interval [a,b] method : str (default=`brentq`) Method to use when computing the steady state. Supported methods are `bisect`, `brenth`, `brentq`, `ridder`. See `scipy.optimize` for more details (including references). kwargs : optional Additional keyword arguments. Keyword arguments are method specific see `scipy.optimize` for details. Returns ------- x0 : float Zero of `f` between `a` and `b`. r : RootResults (present if ``full_output = True``) Object containing information about the convergence. In particular, ``r.converged`` is True if the routine converged. """ if method == 'bisect': result = optimize.bisect(self.evaluate_k_dot, a, b, **kwargs) elif method == 'brenth': result = optimize.brenth(self.evaluate_k_dot, a, b, **kwargs) elif method == 'brentq': result = optimize.brentq(self.evaluate_k_dot, a, b, **kwargs) elif method == 'ridder': result = optimize.ridder(self.evaluate_k_dot, a, b, **kwargs) else: mesg = ("Method must be one of : 'bisect', 'brenth', 'brentq', " + "or 'ridder'.") raise ValueError(mesg) return result
def graph(xmin, xmax): h = abs(xmin - xmax) / 100 dx = 0.01 xlist = mlab.frange(xmin, xmax, dx) ylist = [func(x) for x in xlist] x2 = [] y2 = [] x3 = [] y3 = [] x4 = [xmin, xmax] y4 = [func(xmin), func(xmax)] x = sym.Symbol('x') f = x**3 - 5 * x**2 + 6 f_dif = sym.diff(f, x, 1) extr = sym.solve(f_dif, x) for k in extr: x2.append(float(k)) y2.append(func(float(k))) f_2dif = sym.diff(f_dif, x, 1) peregib = sym.solve(f_2dif, x) for k in peregib: x3.append(float(k)) y3.append(func(float(k))) rootsx = [] rootscount = 0 while xmin < xmax: if func(xmin) * func(xmin + h) < 0: rootsx.append(sp.ridder(func, xmin, xmin + h)) rootscount += 1 xmin += h pylab.plot(xlist, ylist) pylab.grid(True) pylab.plot(rootsx, [0] * rootscount, 'bo', label="Roots") pylab.plot(x2, y2, 'ro', label="Extrema") pylab.plot(x3, y3, 'go', label="Inflection points") pylab.plot(x4, y4, 'yo', label="min/max") pylab.legend() pylab.show()
def find_values(self, func, method, **kwargs): """ Provides an interface to the various methods for finding the root of a univariate or multivariate function in scipy.optimize. Arguments: method: (str) For univariate functions method must be one of: 'brentq', 'brenth', 'ridder', 'bisect', or 'newton'; for multivariate function method must be one of: 'hybr', 'lm', 'broyden1', 'broyden2', 'anderson', 'linearmixing', 'diagbroyden', 'excitingmixing', 'krylov'. **kwargs: (dict) Dictionary of method specific keyword arguments. """ # list of valid multivariate root-finding methods multivariate_methods = [ 'hybr', 'lm', 'broyden1', 'broyden2', 'anderson', 'linearmixing', 'diagbroyden', 'excitingmixing', 'krylov' ] # univariate methods if method == 'brentq': res = optimize.brentq(func, args=self.model.args, **kwargs) elif method == 'brenth': res = optimize.brenth(func, args=self.model.args, **kwargs) elif method == 'ridder': res = optimize.ridder(func, args=self.model.args, **kwargs) elif method == 'bisect': res = optimize.bisect(func, args=self.model.args, **kwargs) elif method == 'newton': res = optimize.newton(func, args=self.model.args, **kwargs) # multivariate methods are handled by optimize.root elif method in multivariate_methods: res = optimize.root(func, args=self.model.args, **kwargs) else: raise ValueError, 'Unrecognized method!' return res
def find_values(self, func, method, **kwargs): """ Provides an interface to the various methods for finding the root of a univariate or multivariate function in scipy.optimize. Arguments: method: (str) For univariate functions method must be one of: 'brentq', 'brenth', 'ridder', 'bisect', or 'newton'; for multivariate function method must be one of: 'hybr', 'lm', 'broyden1', 'broyden2', 'anderson', 'linearmixing', 'diagbroyden', 'excitingmixing', 'krylov'. **kwargs: (dict) Dictionary of method specific keyword arguments. """ # list of valid multivariate root-finding methods multivariate_methods = ['hybr', 'lm', 'broyden1', 'broyden2', 'anderson', 'linearmixing', 'diagbroyden', 'excitingmixing', 'krylov'] # univariate methods if method == 'brentq': res = optimize.brentq(func, args=self.model.args, **kwargs) elif method == 'brenth': res = optimize.brenth(func, args=self.model.args, **kwargs) elif method == 'ridder': res = optimize.ridder(func, args=self.model.args, **kwargs) elif method == 'bisect': res = optimize.bisect(func, args=self.model.args, **kwargs) elif method == 'newton': res = optimize.newton(func, args=self.model.args, **kwargs) # multivariate methods are handled by optimize.root elif method in multivariate_methods: res = optimize.root(func, args=self.model.args, **kwargs) else: raise ValueError, 'Unrecognized method!' return res
def segment_body(body, granularity=0.5): descs = [] for xi, xf in zip(body.layer_boundaries[:-1], body.layer_boundaries[1:]): f_density = body.get_density(xf, right=True) gran = np.abs(f_density - body.get_density(xi, right=False)) / body.get_density( xi, right=False) if gran < granularity: # the percent difference within a layer is small descs.append((xi, xf, body.get_average_density(0.5 * (xi + xf)))) else: start = xi s_density = body.get_density(start, right=True) while np.abs(f_density - s_density) / s_density - granularity > 0: func = lambda x: np.abs( body.get_density(x, right=True) - s_density ) / s_density - granularity end = ridder(func, start, xf) wrap = lambda x: body.get_density(x, right=True) I = quad(wrap, start, end, full_output=1) avg_density = I[0] / (end - start) descs.append((start, end, avg_density)) start = end s_density = body.get_density(start) return descs
def _df_k2(k2, p, nu1, TOL): """ Return `nu2` such that the integral of F(nu1,nu2) from -infty to `x` is `p` `x` is k2**2 * nu2/ ( nu1*(nu2+1) ) """ # We have `k2` the integral limit, so `pf` gives us `p` # we must vary the `nu2` argument until the # returned value equals `p`. # `fdtr` returns the integral of F probability density from -infty to `x` def fn(nu2): x = k2**2 * nu2 / (nu1 * (nu2 + 1)) # return pf(x,nu1,nu2) - p return special.fdtr(nu1, nu2, x) - p # dof here is nu2-1 and cannot be less than 2 # This setting of `lo` is not a strict bound, because # the calculation will succeed, we just don't want to # go there. lo = 1 - 1E-3 fn_lo = fn(lo) if fn_lo > 0.0: raise RuntimeError("dof < 2 cannot be calculated") upper_limit = (20, 50, 1E2, 1E3, inf_dof) for hi in upper_limit: if fn(hi) > 0.0: return optimize.ridder(fn, lo, hi) else: lo = hi return inf
def ridd(f): return opt.ridder(f, -2, 2)
from scipy import optimize def f(x): return 2 * x**4 + 24 * x**3 + 61 * x**2 - 16 * x + 1 root1 = optimize.ridder(f, -9, -8) root2 = optimize.ridder(f, -6, -4) root3 = optimize.ridder(f, -1, 0.122) root4 = optimize.ridder(f, 0.122, 1) print(root1) print(root2) print(root3) print(root4)
import scipy.optimize as sp import numpy as np def f(x): return 2*x**4 + 24*x**3 + 61*x**2 - 16*x + 1 result = [] result.append(sp.ridder(f, -5, 8)) result.append(sp.ridder(f, -9, -6)) print(result) # znalazłem 2 miejsca zerowe
cur_data = data[datetime_start:cur_end] resampled_data = cur_data.resample(sample_size,how = 'mean',base = 0) resampled_data = resampled_data.interpolate() #### Solve for numerical value of time and displacement time_delta = resampled_data.index - resampled_data.index[0] t = map(lambda x: x/np.timedelta64(1,'D'),time_delta) x =np.array(resampled_data.meas.values) #### Solve for the interpolation function of resampled time series f = interpolate.interp1d(t,x) #### Compute for t1, t2 and t3 t1 = t[0] t3 = t[-1] t2 = optimize.ridder(lambda y:f(y)-0.5*(f(t1)+f(t3)),t1,t3) #### Compute for time to failure tr based from Saito (1979) tr = (t2**2.0 - t1*t3) / (2.0*t2 - (t1 + t3)) rup_x.append(cur_data.meas.values[-1]) rup_t.append(tr) #Solve for t x for whole data all_time_delta = data.index - data.index[0] all_t = map(lambda x: x/np.timedelta64(1,'D'),all_time_delta) all_x = data.meas.values #Plot the results #Tableu 20 Colors
def ECM(self): """ ECM Algorithm implementation """ self.kVecCumul = np.cumsum(self.kVec) #Initial estimates self.arule = [1.0 * self.total_failures] self.brule = [1.0 * self.total_failures / self.total_time] self.crule = [1.0] self.ll_list = [self.logL(self.arule[0], self.brule[0], self.crule[0])] self.ll_error_list = [] self.ll_error = 1 j = 0 while (self.ll_error > np.power(10.0, -7)): self.a_est = self.aMLE(self.total_failures, self.tn, self.brule[j], self.crule[j]) self.arule.append(self.a_est) #print("Estimated a: {}".format(self.a_est)) if j == 0: limits_b = self.MLElim(self.bMLE, self.brule[j], self.arule[j + 1], self.crule[j], self.tVec) else: #limits_b = self.MLElim(self.bMLE, self.brule[j], self.arule[j+1], self.crule[j], self.tVec) limits_b = [self.brule[j] / 2, self.brule[j] * 2] b_args = (self.arule[j + 1], self.crule[j], self.tVec) #self.b_est = root(self.bMLE, self.brule[j], b_args, method='krylov') self.b_est = ridder(self.bMLE, limits_b[0], limits_b[1], b_args) #print("Estimated b : {}".format(self.b_est)) self.brule.append(self.b_est) c_args = (self.arule[j + 1], self.brule[j + 1], self.tVec) #self.c_est = fsolve(self.cMLE, self.crule[j], c_args) if j == 0: #print("j is 0 <-------------------------------------------------------------") limits = self.MLElim(self.cMLE, self.crule[j], self.arule[j + 1], self.brule[j + 1], self.tVec) else: #limits = self.MLElim(self.cMLE, self.crule[j], self.arule[j+1], self.brule[j+1], self.tVec) limits = [self.crule[j] / 2, self.crule[j] * 2] #print("c limits:") #print(limits) self.c_est = ridder(self.cMLE, limits[0], limits[1], c_args) #print("Estimated c : {}".format(self.c_est)) self.crule.append(self.c_est) self.ll_list.append(self.logL(self.a_est, self.b_est, self.c_est)) j += 1 self.ll_error = self.ll_list[j] - self.ll_list[j - 1] self.ll_error_list.append(self.ll_error) print('Total iterations : {} '.format(j)) print(self.ll_list[-1], self.arule[-1], self.brule[-1], self.crule[-1]) return { 'll': self.ll_list[-1], 'a': self.arule[-1], 'b': self.brule[-1], 'c': self.crule[-1] }
global y y = np.array([ -0.5403, -0.0104, 0.9423, 1.7445, 1.3073, -0.7718, -2.4986, -0.7903, 2.7334 ]) global cs cs = CubicSpline(x, y) plt.scatter(x, y) x_range = np.arange(1, 3, 0.001) plt.plot(x_range, cs(x_range), label='f(x)') plt.plot(x_range, cs(x_range, 1), label="f'(x)") result = f_prim(2.1, cs) print(f"y'(2.1)= {result}") root_list = [ o.ridder(f, 1.2, 1.3), o.ridder(f, 2.1, 2.2), o.ridder(f, 2.8, 2.9) ] print(f"Miejsca zerowe funkcji f(x): {root_list}") plt.scatter(2.1, result, label='f\'(2.1)') plt.scatter(root_list, np.zeros(len(root_list)), label='f(x)=0') plt.legend() plt.grid() plt.show()
def get_a(self, u , qf, qy, Ef, Lf, Af, phi, z, k, l): return ridder(self.u_a_residuum, 1e-12, self.get_umax[1], args = (u, qf, qy, Ef, Lf, Af, phi, z, k, l))
def getTheta(x): return [optimize.ridder(lambda x: 1. / 8. * (x - np.sin(x)) - xi, 0, 2 * np.pi) for xi in x]
ms.compute_field_energy() # compute the energy density from D c = mp.Cylinder(1.0, material=mp.air) print("energy in cylinder: {}".format(ms.compute_energy_in_objects([c]))) print_heading('5x5 point defect, targeted solver') ms.num_bands = 1 # only need to compute a single band, now! ms.target_freq = (0.2812 + 0.4174) / 2 ms.tolerance = 1e-8 ms.run_tm() # Tuning the Point-defect Mode print_heading('Tuning the 5x5 point defect') old_geometry = ms.geometry # save the 5x5 grid with a missing rod def rootfun(eps): # add the cylinder of epsilon = eps to the old geometry: ms.geometry = old_geometry + [mp.Cylinder(0.2, material=mp.Medium(epsilon=eps))] ms.run_tm() # solve for the mode (using the targeted solver) print("epsilon = {} gives freq. = {}".format(eps, ms.get_freqs()[0])) return ms.get_freqs()[0] - 0.314159 # return 1st band freq. - 0.314159 rooteps = ridder(rootfun, 1, 12) print("root (value of epsilon) is at: {}".format(rooteps)) rootval = rootfun(rooteps) print("root function at {} = {}".format(rooteps, rootval))
print_heading('5x5 point defect, targeted solver') ms.num_bands = 1 # only need to compute a single band, now! ms.target_freq = (0.2812 + 0.4174) / 2 ms.tolerance = 1e-8 ms.run_tm() # Tuning the Point-defect Mode print_heading('Tuning the 5x5 point defect') old_geometry = ms.geometry # save the 5x5 grid with a missing rod def rootfun(eps): # add the cylinder of epsilon = eps to the old geometry: ms.geometry = old_geometry + [ mp.Cylinder(0.2, material=mp.Medium(epsilon=eps)) ] ms.run_tm() # solve for the mode (using the targeted solver) print("epsilon = {} gives freq. = {}".format(eps, ms.get_freqs()[0])) return ms.get_freqs()[0] - 0.314159 # return 1st band freq. - 0.314159 rooteps = ridder(rootfun, 1, 12) print("root (value of epsilon) is at: {}".format(rooteps)) rootval = rootfun(rooteps) print("root function at {} = {}".format(rooteps, rootval))
def main(): pi = np.pi N = 20 a1 = pi / 8. a2 = pi / 4. p1 = 1. / 3. p2 = 5. / 12. x = getChebNodes(N) ax1 = fA(x, p1, 0., a1) ax2 = fA(x, p2, a2, a1) theta1 = getTheta(ax1) theta2 = getTheta(ax2) phi1 = phi(theta1) phi2 = phi(theta2) fp1 = cheb.chebfit(x, phi1, N) fp2 = cheb.chebfit(x, phi2, N) # print fp1 # print fp2 print "Disagreement at pi/8 is %.15f" % (cheb.chebval(1, fp1) - cheb.chebval(1, fp2)) phim1 = cheb.chebval(1, fp2) phim2 = cheb.chebval(-1, fp2) # print phim1; # print phim2; K = 4 M = 3 * pow(2, K) M = 60 K = 5 alphas = np.array([i / float(M) for i in range(2 * K, M + 3)]) Atrue1 = np.linspace(0, pi / 8., 200) Atrue2 = np.linspace(pi / 8., pi / 4., 200) phis1 = cheb.chebval(fX(Atrue1, p1, 0, a1), fp1) phis2 = cheb.chebval(fX(Atrue2, p2, a2, a1), fp2) #alphas = [1./3.] # print cheb.chebval(fX(0,p1,0,a1),fp1) # print cheb.chebval(fX(pi/8,p1,0,a1),fp1)-phim1 r = np.zeros((len(alphas), 2)) err = np.zeros((len(alphas), 2)) for k in range(len(alphas)): p = alphas[k] sx1 = fA(x, p, 0, phim1) sx2 = fA(x, p, phim2, phim1) A1 = np.zeros(len(sx1)) A2 = np.zeros(len(sx1)) # print "p = %f" %p # print sx1 # print sx2 for i in range(1, len(sx1) - 1): A1[i] = optimize.ridder( lambda x: -cheb.chebval(fX(x, p1, 0, a1), fp1) + sx1[i], 0, pi / 8. + .1) A1[-1] = pi / 8. A2 = [optimize.ridder(lambda x: cheb.chebval( fX(x, p2, a2, a1), fp2) - sxi, pi / 8., pi / 4.) for sxi in sx2] # print A1 # print A2 fa1 = cheb.chebfit(x, A1, N) fa2 = cheb.chebfit(x, A2, N) # print fa1 # print fa2 r[k, 0] = abs(fa1[-1]) r[k, 1] = abs(fa2[-1]) err[k, 0] = np.linalg.norm( Atrue1 - cheb.chebval(fX(phis1, p, 0, phim1), fa1)) err[k, 1] = np.linalg.norm( Atrue2 - cheb.chebval(fX(phis2, p, phim2, phim1), fa2)) print "alpha r1 r2 err1 err2" for j in range(len(r)): print " %f %e %e %e %e" % (alphas[j], r[j, 0], r[j, 1], err[j, 0], err[j, 1]) plt.rc('text', usetex=True) plt.rc('font', family='serif') plt.subplots_adjust(hspace=0.4) plt.subplot(211) plt.semilogy(alphas, r) plt.legend([r"$\phi^{-1}_1$", r"$\phi^{-1}_2$"]) xlab = ['1/6', '1/4', '1/3', '2/5', '1/2', '3/5', '2/3', '3/4', '5/6', '1'] ticks = [1. / 6., 1. / 4., 1. / 3., 2. / 5., 1. / 2., 3. / 5., 2. / 3., 3. / 4., 5. / 6., 1.] plt.xticks(ticks, xlab) plt.grid(True) plt.title(r'$\phi^{-1}(x) \approx \sum_k a_k T_k(cx^{\alpha}-1)$') # plt.ylabel(r'a_N') plt.ylabel('coefficient decay') plt.xlabel(r'$\alpha$') plt.subplot(212) plt.xlabel(r'$\alpha$') plt.ylabel('Error') # plt.ylabel(r'$\phi^{-1}_i(x)-\tilde{\phi}_i^{-1}(x)$') plt.semilogy(alphas, err) plt.xticks(ticks, xlab) plt.grid(True) plt.title('Error') plt.legend([r"$\phi^{-1}_1$", r"$\phi^{-1}_2$"]) # plt.show() p3 = 1. p4 = 3. / 5 sx1 = fA(x, p3, 0, phim1) sx2 = fA(x, p4, phim2, phim1) A1 = np.zeros(len(sx1)) A2 = np.zeros(len(sx1)) # print sx1 # print sx2 for i in range(1, len(sx1) - 1): A1[i] = optimize.ridder( lambda x: -cheb.chebval(fX(x, p1, 0, a1), fp1) + sx1[i], 0, pi / 8. + .1) A1[-1] = pi / 8. A2 = [optimize.ridder(lambda x: cheb.chebval( fX(x, p2, a2, a1), fp2) - sxi, pi / 8., pi / 4.) for sxi in sx2] # print A1 # print A2 fa1 = cheb.chebfit(x, A1, N) fa2 = cheb.chebfit(x, A2, N) # print fa1 # print fa2 print "Power for phi1 is %f" % p1 print "Power for phi2 is %f" % p2 print "Power for phi1^(-1) is %f" % p3 print "Power for phi2^(-1) is %f" % p4 fnames = ["phiofA1.txt", "phiofA2.txt", "Aofphi1.txt", "Aofphi2.txt"] coeffs = np.zeros((N + 1, 4)) coeffs[:, 0] = fp1 coeffs[:, 1] = fp2 coeffs[:, 2] = fa1 coeffs[:, 3] = fa2 for i in range(4): f = open(fnames[i], "w") for j in range(len(fa1)): f.write("%.16f, " % (coeffs[j, i])) f.close() for i in range(N + 1): print "%.16f, " % x[i]
funcionTestFourier(freqTest) / np.max(lineas), color='blue', label='interpolación Cuadrática') plt.plot(freq, np.zeros_like(freq), color='black') plt.legend(prop={'size': 13}) plt.savefig("fft" + element + " " + lineS, dpi=dpi, bbox_inches='tight') A = trapz(y=linea, x=lambLinea) beta = 2 * A / linea[lambLinea == 0] / np.pi c = 299792458 vsiniMax = c * beta * 1e-3 #x = np.array([0.0345,0.096,freq[3]+3/4*(freq[4]-freq[3])]) x = np.array([recta(2), recta(4), recta(6)]) #se hace manualmente. x = np.array([ ridder(funcionTestFourier, freq[0], freq[2]), ridder(funcionTestFourier, freq[2], freq[3]), ridder(funcionTestFourier, freq[3], freq[5]) ]) #se hace manualmente. funcionTestFourier = interp1d(freq, lineas) yAlta = np.array([3.832, 7.016, 10.174]) y = np.array([4.147, 7.303, 10.437]) from scipy.stats import linregress from scipy.optimize import curve_fit m, b, r, p, sigma = linregress(x, y) plt.figure() plt.scatter(x, y) plt.plot(x, x * m + b)
full_output=True, xtol=1e-12, ) root_brenth, result_brenth = optimize.brenth(numeric_foc, a=eps, b=1e3 - eps, args=model_params, full_output=True, xtol=1e-12, ) root_ridder, result_ridder = optimize.ridder(numeric_foc, a=eps, b=1e3 - eps, args=model_params, full_output=True, xtol=1e-12, ) root_bisect, result_bisect = optimize.bisect(numeric_foc, a=eps, b=1e3 - eps, args=model_params, full_output=True, xtol=1e-12, ) # newton is more efficient, but convergence not guaranteed! root_newton = optimize.newton(numeric_foc, x0=5e2,