def to909090(gr): """ Reduce a grain in the full range angules to 90x90x90 cube """ # if gr[0]<0.: # gr[0] = 360 + gr[0] from sym import __mmm__ as mmm from sym import cubic sam = mmm() # orthorhombic sample symmetry crm = cubic() # cubic crystal symmetry a = euler(ph=gr[0], th=gr[1], tm=gr[2], echo=False) # ca<-sa mats = [] newa = [] for i in range(len(sam)): dum = np.dot(a, sam[i].T) # ca<-sa H for j in range(len(crm)): nnewa = np.dot(crm[j], dum) # H_ca ca<-sa H_sa mats.append(nnewa) #print len(mats) eul_angs = [] n = 0 for i in range(len(mats)): angs = euler(a=mats[i], echo=False) if all(angs[k]<=90. for k in range(3)) and \ all(angs[k]>=0. for k in range(3)): n = n + 1 #print angs eul_angs.append(angs) temp_gr = [] for i in range(len(eul_angs)): temp_gr.append([eul_angs[i][0], eul_angs[i][1], eul_angs[i][2]]) temp_gr = np.around(temp_gr, decimals=3) temp_gr = unique2d(np.array(temp_gr)) new_gr = [] for i in range(len(temp_gr)): dgr = [temp_gr[i][0],temp_gr[i][1],temp_gr[i][2],gr[-1]/len(temp_gr)] new_gr.append(dgr) return np.array(new_gr)
def Punto_1(): punto_inicio = 0 # s punto_final = longitud / velocidad # s resolucion_euler = euler(funcion_sin_radiacion, cadencia, punto_inicio, punto_final, T_0) resolucion_runge_kutta = runge_kutta(funcion_sin_radiacion, cadencia, punto_inicio, punto_final, T_0) resultados_reales = calcular_resultados_reales(solucion_sin_radiacion, cadencia, punto_inicio, punto_final) guardar_grafico_tiempo_vs_temperatura("Método Euler", resultados_reales, "Solución Analítica", resolucion_euler, "Euler") guardar_grafico_tiempo_vs_temperatura("Método Runge-Kutta", resultados_reales, "Solución Analítica", resolucion_runge_kutta, "Runge-Kutta") error_relativo_euler = calcular_error_relativo(resultados_reales, resolucion_euler) error_relativo_runge_kutta = calcular_error_relativo( resultados_reales, resolucion_runge_kutta) guardar_grafico_error_relativo("Error Relativo Euler", error_relativo_euler) guardar_grafico_error_relativo("Error Relativo Runge-Kutta", error_relativo_runge_kutta)
def createTable(eq, approximation, left, right, h): func = f1 picard = picard1 if (eq.get_pow_x() == 2): func = f2 picard = picard2 table = PrettyTable() table.field_names = [ "X", "Picard method", "Explicit Euler method", "Unexplicit Euler method", "Runge-Kutta method" ] yp_eulerExp = 0 yp_euler = 0 yp_runge = 0 x = left while x <= right: print("\rprocessing...{:.0f}%".format((x * 100) / right), end="\n") yp_eulerExp = euler_explicit(yp_eulerExp, x, h, func) yp_euler = euler(yp_euler, x, h, func) yp_runge = rungeKuttaSecOrder(yp_runge, x, h, func) if (x + h > right): table.add_row([ "{:.1f}".format(x), "{:.4f}".format(0) #picard(x, approximation)) , "{:.4f}".format(yp_eulerExp), "{:.4f}".format(yp_euler), "{:.4f}".format(yp_runge) ]) x += h print("Table for Y' = ", eq.equation, " equation") print(table)
def rsa(n, p, M, e) : """ Crypte le message par le RSA avec les parametres n, p et e """ N = n * p #print "N : " + str(N) phiN = euler(N) #print "phiN : " + str(phiN) d = inverse(e, phiN) #d = d + phiN #print "d : " + str(d) M2 = restexpmn(M, e, N) return M2
def spread(eul=None, w=None, nseg=0): """ Given the the Euler angle set (including the volume), spread the current angle into nseg number of poles based on a distribution with the scatter angle is given as w eul = [ph1, ph, ph2, vf] """ rst = [] vf = eul[3] / nseg a = euler(ph = eul[0], th = eul[1], tm = eul[2], echo=False) for i in range(nseg): ## Generate a random rotation axis, about which the given grain rotates delta, phi = rot_axis() ## Calculates the spread (rotation) matrix b b = spread_matrix( delta, phi, gaussian(w)) ## Rotates the rotation matrix a c = np.zeros((3,3)) for i in range(3): for j in range(3): for m in range(3): c[i,j] = c[i,j] + b[m,i] * a[m,j] pass pass pass #c = np.dot(b.transpose(), a) p1, p, p2 = euler(a=c, echo=False) rst.append([p1, p, p2, vf]) pass ## Returns the spread angle sets return rst
def main(): e = euler() M = [map(int, line[:-1].split(','))for line in open('matrix.txt', 'r')] S = [[0 for i in xrange(len(M[0]))] for j in xrange(len(M))] for i in xrange(len(M)): S[i][0] = M[i][0] S[-1][1] = S[-1][0]+M[-1][1] S[0][1] = S[0][0]+M[0][1] for k in xrange(1): for i in xrange(len(M)): for j in xrange(1, len(M[0])): if i+1 == len(M): S[i][j] = M[i][j] + min(S[i-1][j], S[i][j-1]) elif i-1 < 0: S[i][j] = M[i][j] + min(S[i+1][j], S[i][j-1]) else: S[i][j] = M[i][j] + min(S[i-1][j], S[i+1][j], S[i][j-1]) print min([row[-1] for row in S])
def main(): e = euler() M = [map(int, line[:-1].split(',')) for line in open('matrix.txt', 'r')] S = [[0 for i in xrange(len(M[0]))] for j in xrange(len(M))] for i in xrange(len(M)): S[i][0] = M[i][0] S[-1][1] = S[-1][0] + M[-1][1] S[0][1] = S[0][0] + M[0][1] for k in xrange(1): for i in xrange(len(M)): for j in xrange(1, len(M[0])): if i + 1 == len(M): S[i][j] = M[i][j] + min(S[i - 1][j], S[i][j - 1]) elif i - 1 < 0: S[i][j] = M[i][j] + min(S[i + 1][j], S[i][j - 1]) else: S[i][j] = M[i][j] + min(S[i - 1][j], S[i + 1][j], S[i][j - 1]) print min([row[-1] for row in S])
from euler import * import matplotlib.pyplot as plt h = 0.01 t = 100 pa = np.array([0, 0]) ve = np.array([2, 3]) ac = np.array([0, -10]) #gravedad # Ejercicio plt.figure() vp, vv, va, pt = euler(pa, ve, ac, t, h) vpp = [] for p in vp: if p[1] < -0.05: break vpp.append(p) vp = npa(vpp) plt.plot(vp[:, 0], vp[:, 1]) plt.xlabel('x') plt.ylabel('y') plt.title('x-y') plt.grid(True) plt.show()
if p[1] <= 0: break vpp.append(p) return npa(vpp) h = 0.01 t = 100 pa = np.array([0, 0, 0]) ve = np.array([5, 2, 0]) ac = np.array([0, -10, 0]) #gravedad # Ejercicio fig = plt.figure() vp, vv, va, pt = euler(pa, ve, ac, t, h) ac = np.array([2, -10, 0]) #gravedad vp1, vv1, va1, pt1 = euler(pa, ve, ac, t, h) ac = np.array([-1, -10, 0]) #gravedad vp2, vv2, va2, pt2 = euler(pa, ve, ac, t, h) ac = np.array([2, -10, -1]) #gravedad vp3, vv3, va3, pt3 = euler(pa, ve, ac, t, h) ac = np.array([pow(100, 2) / 5, -10, 0]) #gravedad vp4, vv4, va4, pt4 = euler(pa, ve, ac, t, h) vp1 = limit(vp1) ax = fig.add_subplot(2, 2, 1, projection='3d') ax.plot(vp1[:, 0], vp1[:, 2], vp1[:, 1]) ax.scatter3D([vp1[0, 0]], [vp1[0, 2]], [vp[0, 1]], color="red") ax.scatter3D([vp1[len(vp1) - 1, 0]], [vp1[len(vp1) - 1, 2]], [vp[len(vp1) - 1, 1]],
from euler import * import matplotlib.pyplot as plt h = 0.1 t = 10 a = -10 #gravedad # Ejercicio vp, vv, va, pt = euler(-30, -30, a, t, h) DrawT_E(plt, pt, vp) DrawT_V(plt, pt, vv) DrawT_A(plt, pt, va) DrawE_V(plt, vp, vv) plt.show() vp, vv, va, pt = euler(0, 0, a, t, h) DrawT_E(plt, pt, vp) DrawT_V(plt, pt, vv) DrawT_A(plt, pt, va) DrawE_V(plt, vp, vv) plt.show() vp, vv, va, pt = euler(30, 30, a, t, h) DrawT_E(plt, pt, vp) DrawT_V(plt, pt, vv) DrawT_A(plt, pt, va) DrawE_V(plt, vp, vv) plt.show()
def test_euler1(self) : resultat = euler(1500) self.assertEqual(resultat, 400)
def test_euler5(self) : resultat = euler(euler(1500)) self.assertEqual(resultat, 160)
def test_euler2(self) : resultat = euler(120) self.assertEqual(resultat, 32)
def main(): e = euler() print e.primes(100)
kc = np.zeros(nt+1) rw = np.zeros(nt+1) rs = np.zeros(nt+1) clock_time_init = tm.time() i = np.arange(1,nx) j = np.arange(1,ny) ii,jj = np.meshgrid(i,j, indexing='ij') for k in range(nt+1): w0 = np.copy(w) s0 = np.copy(s) if its == 1: w,s = euler(nx,ny,dx,dy,dt,re,w,s,ii,jj,input_data,bc,bc3) elif its == 2: w,s = rk3(nx,ny,dx,dy,dt,re,w,s,ii,jj,input_data,bc,bc3) kc[k] = k rw[k] = np.linalg.norm(w - w0)/np.sqrt(np.size(w)) rs[k] = np.linalg.norm(s - s0)/np.sqrt(np.size(s)) # if k % freq == 0: print('%0.3i %0.3e %0.3e' % (kc[k], rw[k], rs[k])) if rw[k] <= eps and rs[k] <= eps: break kc = kc[:k+1] rw = rw[:k+1]
from euler import * import matplotlib.pyplot as plt h=0.05 t=20 a = 10 #gravedad # Ejercicio plt.figure() vp,vv,va,pt = euler(-20,15,a,t,h,resta); DrawT_E(plt,pt,vp) DrawT_V(plt,pt,vv) DrawT_A(plt,pt,va) DrawE_V(plt,vp,vv) plt.show() plt.figure() vp,vv,va,pt = euler(-20,0,a,t,h,resta); DrawT_E(plt,pt,vp) DrawT_V(plt,pt,vv) DrawT_A(plt,pt,va) DrawE_V(plt,vp,vv) plt.show() plt.figure() vp,vv,va,pt = euler(20,-15,a,t,h,resta); DrawT_E(plt,pt,vp) DrawT_V(plt,pt,vv) DrawT_A(plt,pt,va) DrawE_V(plt,vp,vv)
def test_euler4(self) : resultat = euler(59) self.assertEqual(resultat, 58)
sw, sb = alphaw, alphab # Planetary albedo planet_albedo = albedo(alphaw, alphab, alphag, aw, ab, ag) # Planetary temperature T = planetary_temp(S, planet_albedo, L=L) # Local temperature Tw = local_temp(planet_albedo, aw, T) Tb = local_temp(planet_albedo, ab, T) # Birth rate betaw = beta(Tw) betab = beta(Tb) # Change in daisies dawdt = daisy_replicator(alphaw, alphag, betaw, gamma) dabdt = daisy_replicator(alphab, alphag, betab, gamma) # Integrate alphaw = euler(alphaw, dawdt) alphab = euler(alphab, dabdt) alphag = p - alphaw - alphab n += 1 # Store the output alphaw_out[i] = alphaw alphab_out[i] = alphab temp_out[i] = T # Plot the results # Cover fractions white = plt.plot(luminosities, alphaw_out * 100, 'b', label='White') black = plt.plot(luminosities, alphab_out * 100, 'k', label='Black') plt.legend(loc='upper right') plt.xlabel('Luminosity') plt.ylabel('Surface cover %')