<jupyter_start><jupyter_text>jQuery(document).ready(function($) {  $(window).load(function(){    $('preloader').fadeOut('slow',function(){$(this).remove();});  });  });  divpreloader { position: fixed;      left: 0;      top: 0;      z-index: 999;      width: 100%;      height: 100%;      overflow: visible;      background: fff url('http://preloaders.net/preloaders/720/Moving%20line.gif') no-repeat center center;  }   Simulación matemática-  Profesor:   <NAME>-  Alumno:  <NAME>-  Año : 2018 > _Favor de realizar los siguiente ejercicios lo más claro posible_. Todos los problemas tiene el mismo valor (5PTS). TOTAL DE PUNTOS 30<jupyter_code>import numpy as np
from scipy.integrate import odeint
import matplotlib.pyplot as plt
%matplotlib inline<jupyter_output><empty_output><jupyter_text>Problema 1 a) Escriba una función que sume todos los dígitos de un entero entre el 0 y 1000._Consejo: Use el operador $\%$ para extraer dígitos, y use el operador // para quitar el dígito extraído_. Por ejemplo, - $ 932 \% 10 = 2 $ - $ 932 // 10 = 93. $Use el siguiente encabezado para dicha función ** def  sum_digits(n):**b) Usted puede aproximar $\pi$ usando la siguiente serie:      $$\pi = 4 \sum_{n=0}^{\infty} \frac{(-1)^n}{2n+1}$$   escriba un programa que muestre el valor de $\pi$ para $n= 10000, 20000,\dots\quad \mbox{y}\quad 100000$.  Respuesta a):<jupyter_code>932%10
932//10
#def sumdigits
def sumdigits(n): 
    n = str(n)
    s = 0
    for i in n:
        s += int(i)
    return s

#Parte del numero aleatorio de 0 1000

#Parte del numero con numeros ingresados por el usuario

#n = int(input("Digite un numero del 0 al 1000: "))
k= np.arange(1001); 
np.random.randn()
o = np.random.choice(k)
o


s2digits = sumdigits(o)

sfinal = int(s2digits)

print(s2digits)

#Parte de la suma
def ultimo(s2digits):
    s2digits = str(s2digits)
    suma2 = int(s2digits)
    for y in s2digits:
        suma2 += int(y)
        return suma2

final = ultimo(s2digits)
o<jupyter_output>14<jupyter_text>Respuesta b):  b) Usted puede aproximar $\pi$ usando la siguiente serie:      $$\pi = 4 \sum_{n=0}^{\infty} \frac{(-1)^n}{2n+1}$$   escriba un programa que muestre el valor de $\pi$ para $n= 10000, 20000,\dots\quad \mbox{y}\quad 100000$.<jupyter_code>from math import pi
from math import sqrt
pi
def espita(d):
    x = []
    q,r,t,k,n,l = 1,0,1,1,3,3
    while len(x) < d:
        if 4*q+r-t < n*t:
            x.append(n)
            q,r,t,k,n,l = (
                10*q,10*(r-n*t),t,k,
                (10*(3*q+r))//t-10*n,l)
        else:
            q,r,t,k,n,l = (
                q*k,(2*q+r)*l,t*l,k+1,
                (q*(7*k+2)+r*l)//(t*l),l+2)
    return x
#espita(100000)
salida = espita(10000)
salida[:5]<jupyter_output><empty_output><jupyter_text>Problema 2 Hacer uso de `interact` para describir el movimiento de una particula en tiro parabólico, tomando en cuenta la resistencia del aire. Indicar el máximo tanto en $x$ como en $y$. - https://en.wikipedia.org/wiki/Projectile_motion<jupyter_code>a=[]
b=[]
# y=0
# x=-50
plt.xlim = 0

for x in range(-50,50,1):
    y=-x**2 + 2*x + 2500
    a.append(x)
    b.append(y)
    #x= x+1
    
fig= plt.figure()
axes=fig.add_subplot(111)
axes.plot(a,b)
plt.show()<jupyter_output><empty_output><jupyter_text>Problema 3  Soluciones a ecuaciones diferenciales de forma numérica.   1. $$(x-1)y'' -xy' +y = 0,\quad y(0) = -2, y'(0)=6 $$   2. $$(x^2+1)y'' +2xy' = 0,\quad y(0) = 0, y'(0)=1 $$ Recuerden hacer una gráfica de la solución para un dominio adecuado. - https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.integrate.odeint.html<jupyter_code># Respuesta:<jupyter_output><empty_output><jupyter_text>Problema 4 Considere una caminata aleatoria en 2D y en 3D. Elementos a mostrar:- Definir una función que realize dicha caminata en 2D y 3D e indicar en código de colores el inicio y el final de la misma. - Ahora suponga que si en algún momento del trayecto la posición del agente esta fuera de una cierta región definada, digamos el rectángulo definido por $a$ y $b$ entonces iniciar un contador e indicar que dicha trayectoria en algún momento excedió dichas dimensiones. Realizar este proceso para $n$ agentes y calcular la probabilidad de que al realizar una caminata salga del rectángulo. - Lo mismo que el caso anterior pero para una esfera de radio $r$.<jupyter_code># Respuesta: 

numeros = np.array([1, 2, 3, 4, 5, 6])
np.cumsum(numeros)
plt.style.use("ggplot")
npasos = 1000
x = np.cumsum(np.random.randn(npasos))
y = np.cumsum(np.random.randn(npasos))
plt.plot(x, y)
plt.show()
plt.scatter(x, y, c = range(npasos), lw = 0, marker = "o", s = 2, cmap = "viridis")
plt.colorbar()
plt.show()
npasos = 1000
plt.style.use("dark_background")
x = np.cumsum(np.random.randn(npasos))
y = np.cumsum(np.random.randn(npasos))
plt.scatter(x, y, c = range(npasos), lw = 0, marker = "o", s = 4, cmap = "inferno")
plt.grid(False)
plt.colorbar()
plt.show()<jupyter_output><empty_output><jupyter_text>Problema 5 **Similar la Barnsley fern realizada en clase**https://en.wikipedia.org/wiki/Barnsley_fern,elegir por lo menos otras dos opciones de https://es.wikipedia.org/wiki/Fractal  Programar y mostrar con una elección de color adecuada.<jupyter_code># Respuesta: 
from numba import autojit
@autojit

def fractal (re, im, max_iter):
    c = complex(re, im)
    z = 0.0j
    
    for i in range(max_iter):
        z = z*z+c
        if(z.real*z.real + z.imag*z.imag) >= 4:
            return i
    return max_iter

columns = 2000
rows = 2000

result = np.zeros([rows, columns])
for row_index, re in enumerate(np.linspace(-2, 1, num=rows)):
    for column_index, im in enumerate(np.linspace(-1,1, num=columns)):
        result[row_index, column_index] = fractal(re, im, 100)

plt.figure(dpi = 100)
plt.imshow(result.T, cmap = "inferno", interpolation="bilinear", extent = [-2,1,-1,1])
plt.xlabel("re")
plt.ylabel("im")
plt.show()
from math import sin, cos, pi
import matplotlib.pyplot as plt
import matplotlib
 
def kochSnowFlake(l, n):
    x_vertex1 = 0
    y_vertex1 = 0
     
    x_vertex2 = l * cos ( 2 * pi/3)
    y_vertex2 = l * sin(2 * pi/3)
     
    x_vertex3 = l * cos (pi/3)
    y_vertex3 = l * sin(pi/3)
     
    kochCurve(x_vertex1, y_vertex1, x_vertex2, y_vertex2, n)
    kochCurve(x_vertex2, y_vertex2, x_vertex3, y_vertex3, n)
    kochCurve(x_vertex3, y_vertex3, x_vertex1, y_vertex1, n)
     
    return
         
def kochCurve(xi, yi, xf, yf, n):
    if n==0:
       plt.plot([xi,xf],[yi,yf])
             
    elif n>0:
        x1 = xi + (xf - xi) / 3.0
        y1 = yi + (yf - yi) / 3.0
 
        x3 = xf - (xf - xi) / 3.0
        y3 = yf - (yf - yi) / 3.0
         
        x2 = (x1 + x3) * cos (pi/3) - ( y3 - y1) * sin (pi/3)
        y2 = (y1 + y3) * cos (pi/3) + ( x3 - x1) * sin (pi/3) 
 
        kochCurve(xi,yi,x1,y1,n-1)
        kochCurve(x1,y1,x2,y2,n-1)
        kochCurve(x2,y2,x3,y3,n-1)
        kochCurve(x3,y3,xf,yf,n-1)
         
    return
   
plt.figure("Koch snowflack")
kochSnowFlake(200,4) # range 1 -6
plt.show()<jupyter_output><empty_output><jupyter_text>Problema 6 Crecimiento de poblaciones. Simule el crecimiento de la población de la tierra. Considerando los siguientes elementos:    - Población inicial en el año $t =0$, 170 millones de personas,   - La razón de nacimientos es $a = 0.005$ y que la razón de muertes es de $b = 0.005$.    - La probabilidad tanto de nacimientos como de muertes es proporcional al tamaño de la población al tiempo $t$.    - Los eventos tanto de nacimiento como de muerte son independientes.   - La evolución se detiene si la población llega a cero o bien a 10000000000. - Mostrar la evolución de la población en el tiempo.- Modifique la población inicial para dos casos y compare con el caso original.<jupyter_code># Respuesta: 
import numpy as np 
import matplotlib.pyplot as plt
%matplotlib inline
import matplotlib as mpl

def PoblacionS(poblacion, tiempo, limite):
    return poblacion * (10**-1 -10**-7 *poblacion)

from scipy.integrate import odeint 

def PoblacionS1(poblacion, tiempo):
    return poblacion * (10**-1 -10**-7 *poblacion)

p0 = 170             
tiempo = np.linspace(0,12)   
xx = odeint(PoblacionS1, p0, tiempo)   


plt.figure()
plt.plot(tiempo, xx)
plt.grid()
plt.xlabel('$t$', fontsize = 18)
plt.ylabel('$Poblacion$', fontsize = 18)
plt.show()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13776551062042483, 'fraction_numerical': 0.044641785671426855, 'mean_word_length': 3.336108220603538, 'pattern_counts': {'":': 0, '<': 36, '<?xml version=': 0, '>': 37, 'https://': 4, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 1, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '8', 'dir': 'jupyter-structured-clean-dedup', 'id': '657691', 'license': 'MIT', 'n_tokens_mistral': 3591, 'n_tokens_neox': 3356, 'n_words': 904, 'path': 'Examen/EvaluacionFinal.ipynb', 'repo_name': 'alejandrasegovia/PrimerTarea', 'size': '8357'}