├── README.md ├── notebooks ├── Notebook de Jupyter.ipynb ├── 21. Ecuacion de Poisson 2D.ipynb ├── 15. Ecuaciones diferenciales ordinarias - enfoque vectorial.ipynb ├── 18. Ecuacion de calor en 2 dimensiones.ipynb ├── 14. Mas alla de Euler.ipynb ├── 19. Problemas estacionarios con valores en la frontera.ipynb ├── 09. El metodo de Newton.ipynb ├── 08. Raices de funciones uni-dimensionales.ipynb ├── 10. Diferencias finitas.ipynb ├── 20. Sistemas de ecuaciones lineales.ipynb ├── 04. Caminatas aleatorias.ipynb ├── Introduccion.ipynb ├── 05. Estadistica de caminatas aleatorias.ipynb ├── 22. Valores y vectores propios.ipynb ├── Metaprogramacion basica.ipynb ├── 13. Ecuaciones diferenciales ordinarias - metodo de Euler.ipynb ├── 11. Interpolacion.ipynb ├── 16. Metodos tipo Runge-Kutta.ipynb └── 03. Iteracion con for.ipynb ├── setup_es.md └── tareas ├── Tarea 2.ipynb └── Tarea 1.ipynb /README.md: -------------------------------------------------------------------------------- 1 | # FisicaComputacional2019_3 2 | 3 | ## Evaluación 4 | 5 | La calificación del curso será con base en su participación en clase, las tareas entrgadas y el proyecto final. 6 | 7 | Pueden consultar las calificaciones de sus tareas en [Calificaciones](https://docs.google.com/spreadsheets/d/1hGv4RxkmWriI3za-buzzATnOC4GMpvOWVcKe_jGxOFU/edit?usp=sharing). Buscar a Crhistian para cualquier aclaración. 8 | 9 | 10 | ## Bibliografía 11 | 12 | Se recomiendan ampliamente los libros: 13 | 14 | - *Computational Physics* de Mark Newman 15 | - *Computational Physics* de Giordano 16 | - *An Introduction to Computer Simulation Methods* de Gould & Tobochnik 17 | -------------------------------------------------------------------------------- /notebooks/Notebook de Jupyter.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## El notebook de Jupyter" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Los guiones de este curso son en formato de **notebooks** (cuadernos) para el entorno **Jupyter** (http://jupyter.org/). Esto es una aplicación que funciona a través de un navegador web, proporcionando así el mismo interfaz al usuario, independientemente de si esté corriendo en una computadora del otro lado del mundo, o en tu propia máquina.\n", 15 | "\n", 16 | "[Si prefieres una aplicación de escritorio, los mismos documentos tipo notebook se pueden utilizar también a través de la aplicación [`Nteract`](https://nteract.io/).]\n", 17 | "\n", 18 | "Para cada notebook, primero haz una copia del notebook (`File->Make a Copy`). Así tendrás una versión limpia, que además se puede actualizar posteriormente sin problemas.\n", 19 | "\n", 20 | "Recomendamos que crees un nuevo directorio con tus copias de los notebooks. Formarán una colección útil de notas y técnicas.\n", 21 | "\n", 22 | "### Teclas en el notebook\n", 23 | "\n", 24 | "Para evaluar una celda, oprime `Shift-Enter`. Puedes ejecutar `Shift-Enter` varias veces para ejecutar celdas contiguas.\n", 25 | "\n", 26 | "En `Help->Keyboard shortcuts`, hay una lista de las teclas que puedes utilizar para llevar a cabo distintas tareas adentro del notebook. Se recomienda ir aprendiendo paulatinamente las combinaciones más útiles. \n", 27 | "\n", 28 | "Para empezar, `Ctrl-m a` (teclear `Ctrl` y `m` juntos, y luego `a`) agrega una celda nueva **a**rriba, y `Ctrl-m b` agrega una a**b**ajo. `Ctrl-m d d` (con dos veces la letra 'd', de \"delete\") borra una celda.\n", 29 | "\n", 30 | "Para regresar a editar después de utilizar un comando, teclea `Enter` en la celda que quieres editar, \n", 31 | "\n", 32 | "### La tecla `tab`\n", 33 | "\n", 34 | "Otra tecla sumamente importante en el notebook es `` (\"tabulador\"), que se encuentra del lado izquierdo del teclado. Si tecleas unas cuantas letras de una palabra, y luego tecleas ``, verás todos los comandos, etc., que empiezan con aquellas letras. Es una manera muy útil de **descubrir** acerca de Julia. Sugerimos acostumbrarte a ¡utilizar `` a cada rato!" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "### Tipos de celdas" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "Hay dos tipos de celdas principales en un notebook:\n", 49 | "\n", 50 | "- Celdas de `Markdown`\n", 51 | "\n", 52 | " - Se utilizan para teclear texto\n", 53 | " \n", 54 | " - `Ctrl-M M`\n", 55 | " \n", 56 | " \n", 57 | "- Celdas de código\n", 58 | "\n", 59 | " - Se utilizan para código\n", 60 | " \n", 61 | " - `Ctrl-M Y`" 62 | ] 63 | } 64 | ], 65 | "metadata": { 66 | "kernelspec": { 67 | "display_name": "Julia 1.0.2", 68 | "language": "julia", 69 | "name": "julia-1.0" 70 | }, 71 | "language_info": { 72 | "file_extension": ".jl", 73 | "mimetype": "application/julia", 74 | "name": "julia", 75 | "version": "1.0.2" 76 | } 77 | }, 78 | "nbformat": 4, 79 | "nbformat_minor": 2 80 | } 81 | -------------------------------------------------------------------------------- /setup_es.md: -------------------------------------------------------------------------------- 1 | ## Correr Julia en línea: JuliaBox 2 | La forma más fácil de correr Julia es en línea, utilizando el servicio [JuliaBox](http://www.juliabox.com). 3 | Este provee una versión en línea de una [Jupyter notebook](http://www.jupyter.org), que se usará durante el curso. Se utiliza `Shift-Enter` para ejecutar una celda. 4 | 5 | Una alternativa es [CoCalc](http://www.cocalc.com), que permite la edición simultánea de las notebooks por distintas personas. 6 | 7 | ## Instalar Julia y Jupyter localmente 8 | Para instalar Julia y Jupyter localmente en sus computadoras, se siguen los siguientes pasos. 9 | 10 | [Nota que *no* es necesario instalar Anaconda de manera separada; Julia hará esto por ti.] 11 | 12 | 1. Descarga e instala la versión estable de Julia (1.0.3) desde [aquí](http://www.julialang.org/downloads) para el sistema operativo que uses. 13 | 14 | 2. Corre la copia de Julia que instalaste. 15 | 16 | Ejecuta los siguientes comandos en la teminal del entorno de Julia ("REPL"), en donde veras un `julia> `. 17 | 18 | 3. Si usas Linux, primero teclea: 19 | ```jl 20 | julia> ENV["JUPYTER"] = "" 21 | ``` 22 | 23 | 4. Ahora instala el paquete IJulia, que automáticamente instalará Jupyter (usando `miniconda`): 24 | ``` 25 | julia> Pkg.add("IJulia") 26 | ``` 27 | 28 | 5. Abre la libreta como sigue. 29 | ```jl 30 | julia> using IJulia 31 | julia> notebook() 32 | ``` 33 | Por default, notebooks nuevas serán creadas en tu directorio principal. Abre o crea una carpeta diferente de tu preferencia para guardarlos en la locación de tu elección. 34 | 35 | 6. Instala algunos otros paquetes que usaremos durante el curso (Necesitaras una conexión a Internet): 36 | ```jl 37 | julia> packages = split( 38 | """Plots Interact 39 | BenchmarkTools 40 | """) 41 | 42 | julia> using Pkg 43 | 44 | julia> for package in packages 45 | Pkg.add(package) 46 | end 47 | ``` 48 | ## Poniéndose al día con la sintaxis básica de Julia 49 | 50 | Si no has tenido un acercamiento a Julia, puedes usar [este video tutorial](https://youtu.be/4igzy3bGVkQ) para ponerte al día con la sintaxis basica de Julia, en particular las notebooks del 1 al 8 (incluyendo "Plotting"). Las libretas están disponibles directamente en JuliaBox o [aquí](https://github.com/JuliaComputing/JuliaBoxTutorials/tree/master/intro-to-julia). 51 | 52 | Sugerimos que añadas a favoritos, descargues o incluso imprimas los siguientes "acordeones" que resume la sintaxis basica de Julia: 53 | - [Resumen de una página por Steven Johnson](https://github.com/stevengj/1806/blob/master/julia/Julia-cheatsheet.pdf) 54 | 55 | - [Resumen más detallado](https://juliadocs.github.io/Julia-Cheat-Sheet) 56 | 57 | Existe una siempre creciente lista de recursos (principalmente en inglés) para aprender Julia, disponibles en la [página de aprendizaje de Julia](http://www.julialang.org/learning) de Julia; en particular revisa [QuantEcon lectures](https://lectures.quantecon.org/jl). 58 | 59 | 60 | ## Julia IDE: Juno 61 | 62 | Existen dos IDEs (Integrated Development Environments) disponibles para Julia: Juno, basada en el editor de texto [Atom](https://atom.io/), y una extensión de Julia para el editor Visual Studio Code. 63 | 64 | Descarga Atom e instale el paqeute `uber-juno`. Más información está disponible en [Juno IDE homepage](http://junolab.org/). 65 | 66 | 67 | ## Preguntas y comentarios 68 | Por favor contactar a [David](dpsanders@ciencias.unam.mx) si tienes alguna duda o comentario. 69 | -------------------------------------------------------------------------------- /notebooks/21. Ecuacion de Poisson 2D.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# La ecuación de Poisson" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En este notebook, veremos cómo podemos resolver la **ecuación de Poisson** en 2D,\n", 15 | "\n", 16 | "$$ \\nabla^2 V(\\mathbf{x}) = -\\rho(\\mathbf{x}) \\qquad (*)$$\n", 17 | "\n", 18 | "para encontrar el potencial y campo eléctrico debido a una distribución de carga $\\rho(\\mathbf{x})$ en una caja cuadrada. Extenderemos la misma idea que aplicamos en 1D." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "#### Ejercicio 1\n", 26 | "Discreticemos la caja de tamaño $L_x \\times L_y$ con $M_x$ y $M_y$ celdas en $x$ y $y$, respectivamente, de tamaños $h_x$ y $h_y$. Denotemos por $V_{i,j}$ el valor aproximado de $V(x_i, y_j)$ en el nodo $(x_i, y_j)$.\n", 27 | "\n", 28 | "(i) Encuentra una aproximación en diferencias finitas para $\\nabla^2 V(x_i, y_j)$ en el punto $(x_i, y_j)$ de la malla." 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": null, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "(ii) Así, escribe la ecuación discretizada correspondiente a (*) en el nodo $(x_i, y_j)$." 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": null, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "#### Ejercicio 2\n", 57 | "Para seguir lo que hicimos en 1D, escribe todas estas ecuaciones, para todas las $i$ y $j$, simultáneamente como *una sola ecuación matricial*. Es decir, \n", 58 | "debemos recolectar todas las $\\phi(x_i, y_j)$ en *un solo vector*.\n", 59 | "\n", 60 | "(i) Inventa una manera de hacer esto (es decir, enlistar los puntos $(x_i, y_j)$ de una forma coherente), y escribe funciones correspondientes para pasar de la posición dada por $(i, j)$ a la posición $k$ en tu lista, y vice versa." 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "(ii) Para sistemas chiquitos, muestra las matrices correspondientes que se generan." 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "#### Ejercicio 3\n", 89 | "\n", 90 | "(i) Resuelve la ecuación de Laplace,\n", 91 | "$$\\nabla^2 V = 0$$ con condiciones de frontera de Dirichlet, es decir, con valores dados en las fronteras. Empieza con el caso que $V=0$ en tres de las fronteras y $V=\\mathrm{constante}$ en la frontera de arriba. " 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": null, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "(ii) Dibuja el potencial como una función en 3D, y como equipotenciales (con la función `contour` o similar)." 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": null, 111 | "metadata": {}, 112 | "outputs": [], 113 | "source": [] 114 | }, 115 | { 116 | "cell_type": "markdown", 117 | "metadata": {}, 118 | "source": [ 119 | "(iii) Encuentra las componentes del campo eléctrico $\\mathbf{E} = -\\nabla \\phi$. Dibuja el campo vectorial usando la función `quiver`." 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": null, 125 | "metadata": {}, 126 | "outputs": [], 127 | "source": [] 128 | }, 129 | { 130 | "cell_type": "markdown", 131 | "metadata": {}, 132 | "source": [ 133 | "(iv) Experimenta con distintas condiciones de frontera. Utiliza `@manipulate`." 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": null, 139 | "metadata": {}, 140 | "outputs": [], 141 | "source": [] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "#### Ejercicio 4\n", 148 | "Resuelve la ecuación de Poisson para una carga puntual tipo delta en algún punto de la malla. Utiliza condiciones de frontera $V(x_i, y_j) = 0$ (representando un campo que decae $0$ a una distancia grande desde la carga). Dibuja el potencial y el campo eléctrico." 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": {}, 155 | "outputs": [], 156 | "source": [] 157 | }, 158 | { 159 | "cell_type": "markdown", 160 | "metadata": {}, 161 | "source": [ 162 | "#### Ejercicio 5\n", 163 | "Encuentra el potencial y el campo eléctrico para un capacitor \"real\", es decir, dos placas paralelas de tamaño finito (menor de la caja), tanto entre las placas como afuera de ellas." 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [] 172 | } 173 | ], 174 | "metadata": { 175 | "kernelspec": { 176 | "display_name": "Julia 1.0.3", 177 | "language": "julia", 178 | "name": "julia-1.0" 179 | }, 180 | "language_info": { 181 | "file_extension": ".jl", 182 | "mimetype": "application/julia", 183 | "name": "julia", 184 | "version": "1.0.3" 185 | }, 186 | "toc": { 187 | "colors": { 188 | "hover_highlight": "#DAA520", 189 | "running_highlight": "#FF0000", 190 | "selected_highlight": "#FFD700" 191 | }, 192 | "moveMenuLeft": true, 193 | "nav_menu": { 194 | "height": "30px", 195 | "width": "252px" 196 | }, 197 | "navigate_menu": true, 198 | "number_sections": true, 199 | "sideBar": true, 200 | "threshold": "2", 201 | "toc_cell": false, 202 | "toc_section_display": "block", 203 | "toc_window_display": false 204 | } 205 | }, 206 | "nbformat": 4, 207 | "nbformat_minor": 1 208 | } 209 | -------------------------------------------------------------------------------- /notebooks/15. Ecuaciones diferenciales ordinarias - enfoque vectorial.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# El enfoque vectorial de EDOs" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Recordemos que *cualquier* EDO, *incluídas las de orden superior* (es decir, con derivadas más altas que la primera de alguna función) se puede escribir de la siguiente manera, conteniendo únicamente primeras derivadas en el tiempo:\n", 15 | "\n", 16 | "$$\\dot{\\mathbf{x}} = \\mathbf{f}(\\mathbf{x}, t),$$\n", 17 | "\n", 18 | "es decir\n", 19 | "\n", 20 | "$$\\dot{\\mathbf{x}}(t) = \\mathbf{f}(\\mathbf{x}(t), t),$$\n", 21 | "\n", 22 | "donde ahora $\\mathbf{x} = (x_1, \\ldots, x_n) \\in \\mathbb{R}^n$ es un vector y $\\mathbf{f}: \\mathbb{R}^n \\to \\mathbb{R}^n$ es una función vectorial, que nos da un **campo vectorial** que indica en cuál dirección moverse desde cada punto del espacio." 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "#### Ejercicio 1\n", 30 | "\n", 31 | "(i) Escribe una función para hacer un paso del método de Euler para las ecuaciones acopladas\n", 32 | "\n", 33 | "$$\\dot{\\mathbf{x}} = \\mathbf{f}(\\mathbf{x}, t).$$\n", 34 | "\n", 35 | "El código ahora deberá ser *genérico*, es decir, debe funcionar para cualquier función $\\mathbf{f}$ y vector $\\mathbf{x}$." 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": null, 41 | "metadata": {}, 42 | "outputs": [], 43 | "source": [] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "(ii) Escribe el método de Euler completo. " 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "(iii) Úsalo para resolver la caída libre y una caída con fricción lineal en la velocidad. Compara con el resultado exacto cuando puedes. Dibuja las resultados con distintos tamaños de fricción." 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": null, 69 | "metadata": {}, 70 | "outputs": [], 71 | "source": [] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "(iv) Resuelve la caída libre con fricción cuadrática en la velocidad." 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": null, 83 | "metadata": {}, 84 | "outputs": [], 85 | "source": [] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "#### Ejercicio 2\n", 92 | "\n", 93 | "(i) Resuelve numéricamente el problema del tiro parabólico con Euler para un proyectil que empieza en una altura $h>0$ con rapidez $1$ y ángulo inicial $\\alpha$, *hasta que* caiga al suelo. [Pista: ¿Cómo puedes implementar esta condición en tu código? Haz una nueva función si sea necesario.]" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "(ii) Encuentra la distancia horizontal donde cae al suelo (el *rango*). Dibuja el resultado tal que puedas manipular interactivamente las condiciones iniciales. Encuentra numéricamente el ángulo que maximiza el rango. ¿Es correcto?" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": null, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "(iii) Agrega fricción del aire al problema y agrégalo como otro parámetro que puedas manipular. ¿Cómo cambia el resultado de la pregunta (ii)?" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "#### Ejercicio 3" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "En el caso del oscilador armónico, podemos hacer mucho de forma analítica. Pero no siempre es el caso:\n", 143 | "\n", 144 | "(i) Escribe la ecuación diferencial ordinaria que modela un péndulo simple amortiguado." 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "(ii) Dibuja el campo vectorial y encuentra distintas trayectorias." 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": null, 164 | "metadata": {}, 165 | "outputs": [], 166 | "source": [] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "(iii) ¿Los resultados coinciden con la intuición física?" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": null, 178 | "metadata": {}, 179 | "outputs": [], 180 | "source": [] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "#### Ejercicio 4 (opcional)\n", 187 | "\n", 188 | "El paquete `StaticArrays.jl` contiene un tipo `SVector` que proporciona vectores con longitud fija. Pueden ser mucho más eficientes (rápidos) cuando los vectores que utilizamos son cortos.\n", 189 | "\n", 190 | "Utiliza tu código con `SVector`s y comprueba si corre más rápido para resolver una ecuación diferencial." 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": null, 196 | "metadata": {}, 197 | "outputs": [], 198 | "source": [] 199 | } 200 | ], 201 | "metadata": { 202 | "kernelspec": { 203 | "display_name": "Julia 1.0.3", 204 | "language": "julia", 205 | "name": "julia-1.0" 206 | }, 207 | "language_info": { 208 | "file_extension": ".jl", 209 | "mimetype": "application/julia", 210 | "name": "julia", 211 | "version": "1.0.3" 212 | } 213 | }, 214 | "nbformat": 4, 215 | "nbformat_minor": 2 216 | } 217 | -------------------------------------------------------------------------------- /tareas/Tarea 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Tarea 2\n", 8 | "\n", 9 | "**Instrucciones**: Igual que para la tarea 1.\n", 10 | "\n", 11 | "Fecha límite de entrega: **lunes 21 de enero de 2019 a las 10am**\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "#### Ejercicio 1 \n", 19 | "\n", 20 | "(i) Escribe la ecuación diferencial para una caída libre vertical con fricción proporcional a la velocidad con coeficiente $\\alpha$." 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": null, 26 | "metadata": {}, 27 | "outputs": [], 28 | "source": [] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "(ii) Resuélvela numéricamente para distintas $\\alpha$ y compara gráficamente con la caída libre sin fricción. ¿Qué observas?" 35 | ] 36 | }, 37 | { 38 | "cell_type": "code", 39 | "execution_count": null, 40 | "metadata": {}, 41 | "outputs": [], 42 | "source": [] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "(iii) Grafica la velocidad como función del tiempo para distintas $\\alpha$. ¿Qué observas? ¿Tiene sentido físico?" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": null, 54 | "metadata": {}, 55 | "outputs": [], 56 | "source": [] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "(iv) Repite lo anterior con fricción cuadrática en la velocidad y compara los comportamientos." 63 | ] 64 | }, 65 | { 66 | "cell_type": "code", 67 | "execution_count": null, 68 | "metadata": {}, 69 | "outputs": [], 70 | "source": [] 71 | }, 72 | { 73 | "cell_type": "markdown", 74 | "metadata": {}, 75 | "source": [ 76 | "#### Ejercicio 2" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "(i) Escribe la ecuación diferencial de un péndulo simple sin amortiguamiento, en términos del ángulo $\\theta$. [Ojo: *No* para ángulos chicos, sino para cualquier ángulo.]" 84 | ] 85 | }, 86 | { 87 | "cell_type": "code", 88 | "execution_count": null, 89 | "metadata": {}, 90 | "outputs": [], 91 | "source": [] 92 | }, 93 | { 94 | "cell_type": "markdown", 95 | "metadata": {}, 96 | "source": [ 97 | "(ii) ¿Es conservativo el sistema? ¿Por qué (no)?" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "(iii) Utiliza el método de Euler para resolver la ecuación, y así graficar trayectorias en el espacio de estados $(\\theta, \\dot{\\theta}$). Empieza desde condiciones iniciales aleatorias e integra tanto para adelante como para atrás en el tiempo.\n", 110 | "\n", 111 | "¿Es correcta la respuesta?" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": {}, 124 | "source": [ 125 | "(iv) Utiliza un método numérico más apropiado para hacer lo mismo." 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "#### Ejercicio 3" 140 | ] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "(i) Escribe las ecuaciones diferenciales para un tiro parabólico en 2D sin fricción, en términos de las variables $x$ y $y$." 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "(ii) Escribe el sistema de *4* EDOs de primer orden correspondientes. " 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "(iii) Escribe un método de Euler para resolver un sistema de 4 variables." 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": null, 180 | "metadata": {}, 181 | "outputs": [], 182 | "source": [] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "(iv) Resuelve el sistema de ecuaciones numéricamente. Dibuja algunas trayectorias y compara con las soluciones exactas correspondientes." 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": null, 194 | "metadata": {}, 195 | "outputs": [], 196 | "source": [] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "#### Ejercicio 4" 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "(i) Escribe las ecuaciones diferenciales para un tiro en 2D con fricción. La fricción es proporcional a la velocidad de la partícula. [Pista: la velocidad ¡es un vector! Puedes escribir las ecuaciones de forma vectorial primero.]" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": null, 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "(ii) Resuelve numéricamente las ecuaciones para encontrar el *alcance* y el ángulo correspondiente para distintos valores del coeficiente de fricción." 224 | ] 225 | }, 226 | { 227 | "cell_type": "code", 228 | "execution_count": null, 229 | "metadata": {}, 230 | "outputs": [], 231 | "source": [] 232 | } 233 | ], 234 | "metadata": { 235 | "kernelspec": { 236 | "display_name": "Julia 1.0.3", 237 | "language": "julia", 238 | "name": "julia-1.0" 239 | }, 240 | "language_info": { 241 | "file_extension": ".jl", 242 | "mimetype": "application/julia", 243 | "name": "julia", 244 | "version": "1.0.3" 245 | } 246 | }, 247 | "nbformat": 4, 248 | "nbformat_minor": 2 249 | } 250 | -------------------------------------------------------------------------------- /notebooks/18. Ecuacion de calor en 2 dimensiones.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# La ecuación de calor en 2D" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Los sistemas físicos raremente viven en 1 sola dimensión. Es más usual que sean dos-dimensionales o tres-dimensionales. \n", 15 | "\n", 16 | "Dado que los sistemas 3D son computacionalmente demandantes, y las ideas a menudo son las mismas que en 2D, nos restringiremos al caso 2D." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "La ecuación de difusión en 2D es\n", 24 | "\n", 25 | "$$\\frac{\\partial u(x,y,t)}{\\partial t} = \\nabla^2 u(x,y,t),$$\n", 26 | "\n", 27 | "donde $\\nabla^2 u(x,y,t) = \\frac{\\partial^2 u(x,y,t)}{\\partial x^2} + \\frac{\\partial^2 u(x,y,t)}{\\partial y^2}$." 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "Para discretizar el sistema, extenderemos lo que ya habíamos hecho en 1D:\n", 35 | "utilizaremos una malla con nodos $(x_i, y_j; t_n)$, con paso $h$ en el tiempo, y tamaños de celda $k$ para $x$, y $l$ para $y$. Notaremos por $u_{i, j}^n$ la aproximación que calcularemos de $u(x_i, y_j; t_n)$." 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "#### Ejercicio 1\n", 43 | "\n", 44 | "(i) Encuentra una discretización de $\\nabla^2 u$ en el punto $(x_i, y_j; t_n)$." 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": null, 50 | "metadata": {}, 51 | "outputs": [], 52 | "source": [] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "(ii) Así, escribe la ecuación discretizada en el punto $(x_i, y_j; t_n)$ la malla, y de ahí la regla para la evolución de Euler en el tiempo." 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "(iii) ¿Cómo son las condiciones de frontera de Dirichlet ahora? ¿Qué esperas ver físicamente para este tipo de condiciones absorbentes?" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": null, 78 | "metadata": {}, 79 | "outputs": [], 80 | "source": [] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": {}, 85 | "source": [ 86 | "#### Ejercicio 2\n", 87 | "\n", 88 | "(i) Implementa esto computacionalmente y haz una animación para una condición inicial tipo delta. \n", 89 | "Ahora en lugar de un vector para representar al estado actual del sistema, necesitarás una *matriz* para las $u^n_{i,j}$ en el tiempo actual $t_n$." 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": null, 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "(ii) ¿Qué ocurre para otras condiciones iniciales?" 104 | ] 105 | }, 106 | { 107 | "cell_type": "code", 108 | "execution_count": null, 109 | "metadata": {}, 110 | "outputs": [], 111 | "source": [] 112 | }, 113 | { 114 | "cell_type": "markdown", 115 | "metadata": {}, 116 | "source": [ 117 | "(iii) Haz animaciones, por ejemplo utilizando `Interact.jl`." 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "#### Ejercicio 3 \n", 132 | "\n", 133 | "(i) Escribe las condiciones de frontera de Neumann para el sistema en un cuadrado." 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": null, 139 | "metadata": {}, 140 | "outputs": [], 141 | "source": [] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "(ii) Discretízalas. " 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": null, 153 | "metadata": {}, 154 | "outputs": [], 155 | "source": [] 156 | }, 157 | { 158 | "cell_type": "markdown", 159 | "metadata": {}, 160 | "source": [ 161 | "(iii) Implementa la evolución con condiciones de Neumann. ¿Qué esperas ver físicamente?" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "metadata": {}, 174 | "source": [ 175 | "(iv) Haz animaciones.\n", 176 | "\n", 177 | "[Nota que se puede reutilizar el mismo código que ya hiciste para las condiciones de Dirichlet, si extraes la parte de implementar las condiciones de frontera a otra función, y mandas esta función como otro argumento a la función principal para escoger cuáles condiciones de frontera se ocuparán.]" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "#### Ejercicio 4\n", 192 | "\n", 193 | "Ahora considera condiciones **periódicas** de frontera. Aquí, el vecino de una celda en la frontera que \"se sale del sistema\" se toma como la celda *del otro lado del sistema*. [Esto le da al sistema la topología de un toro; minimiza el efecto de las fronteras, para simular mejor un sistema de tamaño \"infinito\".]\n", 194 | "\n", 195 | "(i) Para todos los sitios de frontera, calcula cuáles son sus 4 vecinos. Esto se puede hacer utilizando una 4 funciones, una para cada dirección, escritas con `if` o con módulo (`%`)." 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": null, 201 | "metadata": {}, 202 | "outputs": [], 203 | "source": [] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "(ii) Implementa la ecuación de calor con fronteras periódicas. ¿Qué esperas observar?" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": null, 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [] 218 | }, 219 | { 220 | "cell_type": "markdown", 221 | "metadata": {}, 222 | "source": [ 223 | "(iii) Haz animaciones.\n", 224 | "\n", 225 | "**Opcional: Otra manera de implementarlo es copiando las fronteras de un lado del sistema al otro en cada paso para extender las fronteras en una distancia de uno en cada dirección, con llamadas \"celdas fantasma\". Impleméntalo." 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": null, 231 | "metadata": {}, 232 | "outputs": [], 233 | "source": [] 234 | } 235 | ], 236 | "metadata": { 237 | "kernelspec": { 238 | "display_name": "Julia 0.6.2", 239 | "language": "julia", 240 | "name": "julia-0.6" 241 | }, 242 | "language_info": { 243 | "file_extension": ".jl", 244 | "mimetype": "application/julia", 245 | "name": "julia", 246 | "version": "0.6.2" 247 | } 248 | }, 249 | "nbformat": 4, 250 | "nbformat_minor": 1 251 | } 252 | -------------------------------------------------------------------------------- /notebooks/14. Mas alla de Euler.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Euler puede fracasar: sistemas con leyes de conservación" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "El método de Euler es sencillo y útil, pero tiene un defecto importante: ¡puede fracasar!, o sea, no integra correctamente las EDOs. De hecho, resulta que *casi siempre fracasa*, no sólo cuantitativamente, sino también cualitativamente.\n", 15 | "\n", 16 | "Por ejemplo, consideremos la ecuación del péndulo para ángulos pequeños, o sea, un oscilador armónico simple, ahora *sin* amortiguamiento." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "#### Ejercicio 1\n", 24 | "\n", 25 | "(i) Escribe la ecuación de movimiento del oscilador armónico simple, en términos del ángulo $\\theta$ del péndulo desde el vertical, y la velocidad angular $\\omega$." 26 | ] 27 | }, 28 | { 29 | "cell_type": "code", 30 | "execution_count": null, 31 | "metadata": {}, 32 | "outputs": [], 33 | "source": [] 34 | }, 35 | { 36 | "cell_type": "markdown", 37 | "metadata": {}, 38 | "source": [ 39 | "(ii) Dibuja el campo vectorial." 40 | ] 41 | }, 42 | { 43 | "cell_type": "code", 44 | "execution_count": null, 45 | "metadata": {}, 46 | "outputs": [], 47 | "source": [] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "(iii) Integra la ecuación utilizando el método de Euler dibuja bastantes trayectorias en el espacio fase $(\\theta, \\omega)$, empezando desde distintas condiciones iniciales.\n", 54 | " ¿Tienen sentido físico? ¿Por qué?" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": null, 60 | "metadata": {}, 61 | "outputs": [], 62 | "source": [] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "(iv) Recuerda que este sistema físico tiene una propiedad especial: existe una **ley de conservación**. ¿Cuál es la cantidad física que se conserva? Escríbela en términos de $\\theta$ y $\\omega$." 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": null, 74 | "metadata": {}, 75 | "outputs": [], 76 | "source": [] 77 | }, 78 | { 79 | "cell_type": "markdown", 80 | "metadata": {}, 81 | "source": [ 82 | "(v) Dado que esta cantidad se conserva, ¿qué debe satisfacer una trayectoria que sale de una condición inicial dada? [Pista: piensa en **curvas de nivel**.] ¿Por qué? ¿Puedes escribir una ecuación que describe cómo evoluciona la cantidad conservada a lo largo del tiempo?" 83 | ] 84 | }, 85 | { 86 | "cell_type": "code", 87 | "execution_count": null, 88 | "metadata": {}, 89 | "outputs": [], 90 | "source": [] 91 | }, 92 | { 93 | "cell_type": "markdown", 94 | "metadata": {}, 95 | "source": [ 96 | "(vi) Utiliza `contour` para dibujar curvas de nivel, y compáralos gráficamente con las trayectorias que da Euler. ¿Qué observas?" 97 | ] 98 | }, 99 | { 100 | "cell_type": "code", 101 | "execution_count": null, 102 | "metadata": {}, 103 | "outputs": [], 104 | "source": [] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "(vii) Calcula numéricamente cómo varía la cantidad \"conservada\" a lo largo de una trayectoria calculada con Euler. ¿Qué ocurre?" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "# El método de Euler–Cromer" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "Un cambio aparentemente insignificativo al método numérico puede dar resultados mucho mejores para ciertas clases de sistema.\n", 132 | "\n", 133 | "En el llamado método de Euler–Cromer, actualizamos\n", 134 | "*primero* la velocidad, y utilizamos esta *nueva* velocidad para actualizar la posición en las reglas usuales del método de Euler." 135 | ] 136 | }, 137 | { 138 | "cell_type": "markdown", 139 | "metadata": {}, 140 | "source": [ 141 | "#### Ejercicio 2\n", 142 | "\n", 143 | "(i) Escribe una función para Euler–Cromer." 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": null, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [] 152 | }, 153 | { 154 | "cell_type": "markdown", 155 | "metadata": {}, 156 | "source": [ 157 | "(ii) Aplica el método de Euler-Cromer al oscilador armónico. Dibuja trayectorias desde varios puntos iniciales en un solo plano fase, junto con las curvas de nivel y campo vectorial correspondientes." 158 | ] 159 | }, 160 | { 161 | "cell_type": "code", 162 | "execution_count": null, 163 | "metadata": {}, 164 | "outputs": [], 165 | "source": [] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": {}, 170 | "source": [ 171 | "(iii) (Opcional) Encuentra la tasa de convergencia de Euler-Cromer a la solución exacta cuando el tamaño $h$ de un paso converge a cero. ¿Cómo se compara con la tasa de convergencia del método de Euler?" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "# El método de Euler hacia atrás" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "Tomemos otro punto de vista de los métodos numéricos para las EDOs.\n", 193 | "\n", 194 | "Al integrar los dos lados de la EDO\n", 195 | "\n", 196 | "$$\\dot{x}(t) = f(x(t), t)$$\n", 197 | "\n", 198 | "con respecto al tiempo para $t$ entre $t_0$ y $t_0+h$, obtenemos\n", 199 | "\n", 200 | "$$x(t_0+h) - x(t_0) = \\int_{t_0}^{t_0+h} f(x(t'), t') \\, dt'.$$\n", 201 | "\n", 202 | "Por lo tanto, podemos intentar aplicar los métodos numéricos que ya vimos para calcular integrales definidas a este problema." 203 | ] 204 | }, 205 | { 206 | "cell_type": "markdown", 207 | "metadata": {}, 208 | "source": [ 209 | "#### Ejercicio 3\n", 210 | "\n", 211 | "(i) ¿A cuál método de integración numérica corresponde el método de Euler? - es decir, ¿cómo se aproxima la función $f$ adentro de la integral?" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "(ii) Supón (para simplicidad) que $f$ no depende explícitamente de $t$ y escribe una fórmula analítica de cómo sería un paso del método del trapecio a la integral para encontrar una ecuación para $x(t_0 + h)$. ¿Qué *tipo de* ecuación resulta?" 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": null, 231 | "metadata": {}, 232 | "outputs": [], 233 | "source": [] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "metadata": {}, 238 | "source": [ 239 | "(iii) ¿Cuál método numérico podemos aplicar para resolver esta ecuación?" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": null, 245 | "metadata": {}, 246 | "outputs": [], 247 | "source": [] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "(iv) Implementa esto y pruébalo. Compara los resultados con los del método de Euler. ¿Converge más rápido?" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [] 262 | }, 263 | { 264 | "cell_type": "markdown", 265 | "metadata": {}, 266 | "source": [ 267 | "(v) ¿Cómo se puede aplicar para sistemas con dos variables?" 268 | ] 269 | }, 270 | { 271 | "cell_type": "code", 272 | "execution_count": null, 273 | "metadata": {}, 274 | "outputs": [], 275 | "source": [] 276 | } 277 | ], 278 | "metadata": { 279 | "kernelspec": { 280 | "display_name": "Julia 1.0.3", 281 | "language": "julia", 282 | "name": "julia-1.0" 283 | }, 284 | "language_info": { 285 | "file_extension": ".jl", 286 | "mimetype": "application/julia", 287 | "name": "julia", 288 | "version": "1.0.3" 289 | }, 290 | "toc": { 291 | "colors": { 292 | "hover_highlight": "#DAA520", 293 | "running_highlight": "#FF0000", 294 | "selected_highlight": "#FFD700" 295 | }, 296 | "moveMenuLeft": true, 297 | "nav_menu": { 298 | "height": "66px", 299 | "width": "252px" 300 | }, 301 | "navigate_menu": true, 302 | "number_sections": true, 303 | "sideBar": true, 304 | "threshold": "2", 305 | "toc_cell": false, 306 | "toc_section_display": "block", 307 | "toc_window_display": false 308 | } 309 | }, 310 | "nbformat": 4, 311 | "nbformat_minor": 1 312 | } 313 | -------------------------------------------------------------------------------- /notebooks/19. Problemas estacionarios con valores en la frontera.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Problemas estacionarios con valores en la frontera" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Hasta ahora, hemos estudiado únicamente las **ecuaciones de evolución**, o sea, problemas **con valores iniciales**, en los cuales se quiere determinar la evolución temporal de la solución, tanto para EDOs como para EDPs.\n", 15 | "\n", 16 | "Otra clase fundamental de problemas son los **problemas estacionarios** o **problemas estáticos**, también llamados **problemas con valores en la frontera**. En este tipo de problemas, se busca una solución estacionaria, es decir, una solución que *no* cambia en el tiempo, pero que sí depende del espacio.\n", 17 | "\n", 18 | "Este tipo de problemas surge en distintos contextos. Por ejemplo, si resolvemos la ecuación de difusión con condiciones de Dirichlet dadas que no sean cero, la solución temporal *converge* a una solución estacionaria. ¿Podemos calcular directamente esta solución estacionaria? Los problemas estacionarios también ocurren naturalmente al resolver, por ejemplo, las ecuaciones de Laplace y de Poisson para determinar el potencial (y de ahí el campo) eléctrico para una configuración dada de cargas y fronteras." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "## Las ecuaciones de Poisson y de Laplace " 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Consideremos el problema de encontrar el campo de potencial debido a una distribución de carga eléctrica. El campo de potencial $V(\\mathbf{x})$ satisface la ecuación de Poisson,\n", 33 | "\n", 34 | "$$ \\nabla^2 V(\\mathbf{x}) = -\\rho(\\mathbf{x}), $$\n", 35 | "\n", 36 | "donde $\\rho(\\mathbf{x})$ es la densidad de carga en unidades adecuadas.\n", 37 | "Si hay, por ejemplo, dos placas con potenciales dados, entonces queremos resolver este problema con los valores en la frontera $V = V_1$ y $V = V_2$ en las dos placas.\n", 38 | "\n", 39 | "Para comenzar, reduzcamos el problema a una sola dimensión. Entonces la ecuación se vuelve\n", 40 | "\n", 41 | "$$ \\frac{d^2 V(x)}{dx^2} = -\\rho(x) \\quad (*) $$ \n", 42 | "\n", 43 | "para todas las $x$,\n", 44 | "con $V(a) = x_1$ y $V(b) = x_2$,\n", 45 | "es decir, una EDO con valores en la frontera.\n", 46 | "\n", 47 | "Este tipo de problema tiene una naturaleza *completamente diferente* de los que hemos visto anteriormente en EDOs, ya que *no hay evolución* en el tiempo. Y sin embargo..." 48 | ] 49 | }, 50 | { 51 | "cell_type": "markdown", 52 | "metadata": {}, 53 | "source": [ 54 | "#### Ejercicio 1\n", 55 | "\n", 56 | "(i) Discretiza la ecuación con una malla en el espacio, tal como hicimos para la ecuación de difusión: ¿cuál ecuación discretizada se satisface en el sitio $x_i$? " 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": null, 62 | "metadata": {}, 63 | "outputs": [], 64 | "source": [] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "(ii) ¿Si hay una sola carga puntual, cuáles sitios son especiales?" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "(iii) Dado que ya no hay evolución en el tiempo, todas las ecuaciones para todos los sitios $i$ **se deben cumplir simultáneamente**. \n", 85 | "\n", 86 | "¿Qué tipo de problema resulta entonces? Escribe el problema con una notación breve que ya conoces de otros cursos." 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": null, 92 | "metadata": {}, 93 | "outputs": [], 94 | "source": [] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "metadata": {}, 99 | "source": [ 100 | "## Método iterativo de solución" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "Hay varios métodos posibles para resolver problemas de esta índole. Empezaremos con ocupar un método **iterativo** que recién vimos:" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "#### Ejercicio 2\n", 115 | "\n", 116 | "(i) Reescribe la ecuación en el sitio $x_i$ que encontraste en la pregunta **1** para despejar $V_i$, el valor aproximado de $V(x_i)$.\n", 117 | "\n", 118 | "Ahora **inventemos** una dinámica, de una manera parecida a la que utilizamos con los primeros métodos iterativos para resolver ecuaciones: pongamos esta $V_i$ como $V_i^{t+1}$, y los demás $V_i$ como $V_i^t$." 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "(ii) Escribe la nueva ecuación. ¿Cómo se relaciona la solución de la ecuación (*) con esta dinámica?" 133 | ] 134 | }, 135 | { 136 | "cell_type": "code", 137 | "execution_count": null, 138 | "metadata": {}, 139 | "outputs": [], 140 | "source": [] 141 | }, 142 | { 143 | "cell_type": "markdown", 144 | "metadata": {}, 145 | "source": [ 146 | "(iii) Implementa esta dinámica para el caso cuando $\\rho(x) \\equiv 0$, es decir, la **ecuación de Laplace** con condiciones en la frontera $V(x=0) = a$ y $V(x=1) = b$. Haz una animación con `Interact.jl`." 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": null, 152 | "metadata": {}, 153 | "outputs": [], 154 | "source": [] 155 | }, 156 | { 157 | "cell_type": "markdown", 158 | "metadata": {}, 159 | "source": [ 160 | "(iv) Encuentra la solución analítica de la ecuación diferencial y compáralo con tu solución. [Nota que tendrás que esperar bastante tiempo para que la solución a la ecuación dinámica converja.]" 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "(v) ¿De qué es discretización la ecuación dinámica?, es decir, ¿cuál ecuación de evolución estamos resolviendo? ¿Por qué es tan lenta la convergencia?" 175 | ] 176 | }, 177 | { 178 | "cell_type": "code", 179 | "execution_count": null, 180 | "metadata": {}, 181 | "outputs": [], 182 | "source": [] 183 | }, 184 | { 185 | "cell_type": "markdown", 186 | "metadata": {}, 187 | "source": [ 188 | "#### Ejercicio 3\n", 189 | "\n", 190 | "(i) Utiliza la misma técnica para resolver la siguiente EDO con valores en la frontera para $y(x)$:\n", 191 | "\n", 192 | "\\begin{align}\n", 193 | "y'' + y &= 0 \\\\\n", 194 | "y(0) &= 0\\\\\n", 195 | "y \\left( \\frac{\\pi}{2} \\right) &= 2\n", 196 | "\\end{align}\n", 197 | "\n", 198 | "Compara tu solución con el resultado analítico." 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": {}, 205 | "outputs": [], 206 | "source": [] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "(ii) ¿Qué ocurre si cambias las condiciones en la frontera a $y(0) = 1$ y $y(\\frac{\\pi}{2}) = 2$?" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": null, 218 | "metadata": {}, 219 | "outputs": [], 220 | "source": [] 221 | }, 222 | { 223 | "cell_type": "markdown", 224 | "metadata": {}, 225 | "source": [ 226 | "#### Ejercicio 4\n", 227 | "\n", 228 | "Ahora pensemos en la ecuación de Poisson en 1D con una carga puntual en la posición $x_0$.\n", 229 | "\n", 230 | "(i) ¿Cómo puedes modelar matemáticamente la carga puntual? Para tratar esto numéricamente, utilizamos la misma técnica que anteriormente." 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": null, 236 | "metadata": {}, 237 | "outputs": [], 238 | "source": [] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": {}, 243 | "source": [ 244 | "(ii) Escribe la ecuación diferencial y discretízala, tomando cuidado con los puntos especiales." 245 | ] 246 | }, 247 | { 248 | "cell_type": "code", 249 | "execution_count": null, 250 | "metadata": {}, 251 | "outputs": [], 252 | "source": [] 253 | }, 254 | { 255 | "cell_type": "markdown", 256 | "metadata": {}, 257 | "source": [ 258 | "(iii) Impleméntalo y verifica que la solución sea correcta." 259 | ] 260 | }, 261 | { 262 | "cell_type": "code", 263 | "execution_count": null, 264 | "metadata": {}, 265 | "outputs": [], 266 | "source": [] 267 | } 268 | ], 269 | "metadata": { 270 | "kernelspec": { 271 | "display_name": "Julia 1.0.3", 272 | "language": "julia", 273 | "name": "julia-1.0" 274 | }, 275 | "language_info": { 276 | "file_extension": ".jl", 277 | "mimetype": "application/julia", 278 | "name": "julia", 279 | "version": "1.0.3" 280 | } 281 | }, 282 | "nbformat": 4, 283 | "nbformat_minor": 1 284 | } 285 | -------------------------------------------------------------------------------- /notebooks/09. El metodo de Newton.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# El método de Newton" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "El método de Newton (también llamado algoritmo de Newton-Raphson) constituye otro método numérico iterativo para encontrar raíces de una función $f$. \n", 15 | "\n", 16 | "Requiere más información, a saber la **derivada** $f'$, pero a cambio suele funcionar mucho mejor. Derivaremos e implementaremos el método en este notebook. Por el momento, supondremos que el usuario provea también la derivada analítica de la función $f$, como otro argumento `df`; posteriormente en el curso, veremos cómo calcular derivadas numéricamente." 17 | ] 18 | }, 19 | { 20 | "cell_type": "markdown", 21 | "metadata": {}, 22 | "source": [ 23 | "#### Ejercicio 1 (Esta pregunta se lleva a cabo con papel y pluma)\n", 24 | "\n", 25 | "Considera una función $f: \\mathbb{R} \\to \\mathbb{R}$.\n", 26 | "Supón que $x_0$ es una adivinanza inicial de una raíz, y que $x^*$ es la raíz exacta pero \n", 27 | "desconocida. Sigue los siguientes pasos para derivar el método de Newton.\n", 28 | "\n", 29 | "(i) Supón que $x_0$ es suficientemente cercana a $x^*$. Define $\\delta$ como la distancia (con signo) de $x_0$ desde $x^*$. " 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "(ii) Escribe la ecuación que corresponde a que $x^*$ sea una raíz de la función, y exprésala en términos de $\\delta$. " 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "(iii) Desarrolla esta ecuación en una serie de Taylor a primer orden alrededor de $x_0$, para encontrar un valor aproximado de $\\delta$." 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": null, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [] 66 | }, 67 | { 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "(iv) Así encuentra una ecuación para la siguiente aproximación a la raíz, $x_1 = x_0 + \\delta$. " 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "(v) Por lo tanto, dada una adivinanza, podemos obtener otra que esperemos esté mejor (más cerca a la raíz). Escribe la misma ecuación que obtuviste en (iv), pero ahora para $x_{n+1}$ en términos de $x_n$. Esto es la regla general para el método de Newton." 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "#### Ejercicio 2\n", 100 | "\n", 101 | "Demuestra que el método Babilónico es un caso particular del método de Newton. [Pista: ¿Para cuál función $f$?]" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "#### Ejercicio 3" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "(i) Escribe una función que implementa el método de Newton. Puedes suponer que el usuario provea tanto la función `f` como su derivada `df` como argumentos a la función `newton`, así como la condición inicial `x0`. [Posteriormente veremos cómo calcular derivadas con la computadora.] [NB: Si prefieres, puedes utilizar `f′` como nombre de la derivada, al teclear `f\\prime`. *No* se puede utilizar el apóstrofe aquí.]" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "(ii) Para la función $x \\mapsto x^2$, dibuja la dinámica del método de Newton, dada una función $f$ y una condición inicial $x_0$. Para hacerlo, dibuja una recta entre cada $(x_n, 0)$ y $(x_n, f(x_n))$, así como entre $(x_n, f(x_n)$ y $(x_{n+1}, 0)$. Hazlo interactivo con `Interact.jl` (dibujando los primeros $n$ pasos y cambiando $n$). Viendo la figura, interpreta geométricamente lo que está haciendo el método de Newton." 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "(iii) Aplica el método de Newton para encontrar raíces de distintas funciones. ¿Qué ocurre si empiezas con distintas condiciones iniciales?" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": null, 156 | "metadata": {}, 157 | "outputs": [], 158 | "source": [] 159 | }, 160 | { 161 | "cell_type": "markdown", 162 | "metadata": {}, 163 | "source": [ 164 | "#### Ejercicio 4" 165 | ] 166 | }, 167 | { 168 | "cell_type": "markdown", 169 | "metadata": {}, 170 | "source": [ 171 | "¿Qué tan rápido converge el método cuando esté cerca de una raíz? Corre el algoritmo utilizando `BigFloat`s para averiguarlo y grafica la convergencia. ¿El método de Newton es mejor que bisección? ¿Por qué (no)?" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "#### Ejercicio 5" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "Sin embargo, es posible que el método de Newton *no converja*, como sigue." 193 | ] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": {}, 198 | "source": [ 199 | "(i) El mismo código del método de Newton debería funcionar con números complejos. Utilízalo para encontrar raíces de la función $f(z) = z^3 -1$ **en el plano complejo**.\n", 200 | "[Nota que la parte imaginaria $i = \\sqrt{-1}$ se escribe como `im` en Julia. Hay funciones `real` e `imag` para extraer las partes reales e imaginarias de un número complejo.]" 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": null, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "(ii) Escribe una función que verifica si convergió después de un número dado de iterados. Si sí, regresa la parte imaginaria de la raíz a la cual convergió." 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "(iii) Haz el cálculo para una malla de condiciones iniciales en el plano complejo alrededor de $0$. Dibuja la matriz correspondiente. ¿Qué observas? [Pista: Puedes utilizar una comprehensión de arreglo 2-dimensional.]" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "#### Ejercicio 6\n", 243 | "\n", 244 | "Considera ahora cómo encontrar raíces de un sistema de ecuaciones, escrito en forma vectorial:\n", 245 | "\n", 246 | "$$\\mathbf{f}(\\mathbf{x}) = \\mathbf{0}.$$\n", 247 | "\n", 248 | "Repite un desarrollo siguiendo la pauta del ejercicio **1** en este contexto.\n", 249 | "¿Qué es lo que cambia? ¿Qué tipo de operación numérica necesitaríamos para llevar a cabo el método de Newton en este nuevo contexto? [No es necesario que lo implementes por el momento -- opcional.]" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [] 258 | } 259 | ], 260 | "metadata": { 261 | "kernelspec": { 262 | "display_name": "Julia 1.0.3", 263 | "language": "julia", 264 | "name": "julia-1.0" 265 | }, 266 | "language_info": { 267 | "file_extension": ".jl", 268 | "mimetype": "application/julia", 269 | "name": "julia", 270 | "version": "1.0.3" 271 | }, 272 | "toc": { 273 | "colors": { 274 | "hover_highlight": "#DAA520", 275 | "running_highlight": "#FF0000", 276 | "selected_highlight": "#FFD700" 277 | }, 278 | "moveMenuLeft": true, 279 | "nav_menu": { 280 | "height": "29px", 281 | "width": "251px" 282 | }, 283 | "navigate_menu": true, 284 | "number_sections": true, 285 | "sideBar": true, 286 | "threshold": "2", 287 | "toc_cell": false, 288 | "toc_section_display": "block", 289 | "toc_window_display": false 290 | } 291 | }, 292 | "nbformat": 4, 293 | "nbformat_minor": 2 294 | } 295 | -------------------------------------------------------------------------------- /tareas/Tarea 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Tarea 1\n", 8 | "\n", 9 | "\n", 10 | "## Instrucciones\n", 11 | "- Cambia el nombre del notebook para incluir tu nombre de pila y apellido.\n", 12 | "\n", 13 | "\n", 14 | "- Luego, manda el notebook a Crhistian: crhisbenitez@ciencias.unam.mx\n", 15 | "\n", 16 | "\n", 17 | "- La fecha **límite** de entrega es el **lunes 14 de enero de 2019**, a las 10:00 horas" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "## Caminantes aleatorios en más dimensiones" 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Es interesante extender el modelo de caminatas aleatorias a 2 y 3 dimensiones, ya que es físicamente más realista." 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "#### Ejercicio 1" 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "Considera un caminante aleatorio en 2D, con coordenadas $x$ y $y$, que vive en $\\mathbb{Z}^2$." 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "(i) Inicializa al caminante en el origen." 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": null, 58 | "metadata": {}, 59 | "outputs": [], 60 | "source": [] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "(ii) Escribe una función que hace un paso del caminante. Puede moverse sólo arriba, abajo, a la izquierda o a la derecha en cada paso, con probabilidades iguales. [Pista: Primero puedes escoger si se moverá verticalmente u horizontalmente, luego en qué dirección.]" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": null, 72 | "metadata": {}, 73 | "outputs": [], 74 | "source": [] 75 | }, 76 | { 77 | "cell_type": "markdown", 78 | "metadata": {}, 79 | "source": [ 80 | "(iii) Escribe una función que calcula la trayectoria de un caminante. Puedes regresar las coordenadas $x$ y $y$ de forma separada." 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "(iv) Dibuja unas cuantas trayectorias en una sola gráfica." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "(v) Simula una nube de caminantes. Dibuja las posiciones de todos los caminantes en la nube en varios momentos de tiempo en una sola gráfica. ¿Cómo es la evolución?" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "(vi) Calcula y grafica la evolución en el tiempo de la varianza de las posiciones de los caminantes, tanto en $x$ como en $y$. ¿Qué observas?" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": null, 128 | "metadata": {}, 129 | "outputs": [], 130 | "source": [] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": {}, 135 | "source": [ 136 | "#### Ejercicio 2\n", 137 | "\n", 138 | "Simula caminantes en 3D y dibuja algunas trayectorias. [Pista: `plot(xx, yy, zz)` dibuja en 3D. Desgraciadamente no es posible rotar la gráfica con GR. Puedes intentar con `PlotlyJS`:\n", 139 | "\n", 140 | " using Pkg\n", 141 | " \n", 142 | " Pkg.update()\n", 143 | " \n", 144 | " Pkg.add(\"PlotlyJS\")\n", 145 | " \n", 146 | " using Plots\n", 147 | " plotlyjs()\n", 148 | " \n", 149 | "]" 150 | ] 151 | }, 152 | { 153 | "cell_type": "markdown", 154 | "metadata": {}, 155 | "source": [ 156 | "## Caminatas en el espacio" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "Hasta ahora, las caminatas han vivido sobre los enteros únicamente. Pero eso no es necesario; pueden vivir en el espacio real." 164 | ] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "#### Ejercicio 3" 171 | ] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "(i) Escribe una función `uniforme` que utilice `rand` para generar un número aleatorio distribuido uniformemente en el intervalo $[-1, 1]$." 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": null, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "(ii) Verifica con un histograma que tu generador realmente cumpla con esta propiedad." 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": null, 197 | "metadata": {}, 198 | "outputs": [], 199 | "source": [] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "(iii) Utiliza `uniforme` para hacer una simulación de un caminante aleatorio en el espacio 2D que cambia su posición tanto en $x$ como en $y$ en cada paso." 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": {}, 212 | "outputs": [], 213 | "source": [] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "(iv) Visualiza algunas trayectorias y grafica la evolución de la varianza." 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": null, 225 | "metadata": {}, 226 | "outputs": [], 227 | "source": [] 228 | }, 229 | { 230 | "cell_type": "markdown", 231 | "metadata": {}, 232 | "source": [ 233 | "## Tiempos de primer paso" 234 | ] 235 | }, 236 | { 237 | "cell_type": "markdown", 238 | "metadata": {}, 239 | "source": [ 240 | "Considera un caminante aleatorio simple en 1D (como el primero que vimos, con probabilidades iguales de brincar a la derecha y a la izquierda), el cual vive en los enteros. \n", 241 | "\n", 242 | "El caminante comienza en 1 y queremos calcular el tiempo que tarda en llegar a 0, llamado el **tiempo de primer paso** a 0." 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "#### Ejercicio 4\n", 250 | "\n", 251 | "(i) Escribe una función que calcula una trayectoria del caminante desde $1$ hasta que llegue a $0$. Vive en una caja de longitud $L$ con frontera reflejante: si intenta brincar más allá que la posición $L$, es reflejado por la frontera, y se queda en $L$." 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "(ii) Dibuja algunas trayectorias en una sola gráfica." 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": null, 271 | "metadata": {}, 272 | "outputs": [], 273 | "source": [] 274 | }, 275 | { 276 | "cell_type": "markdown", 277 | "metadata": {}, 278 | "source": [ 279 | "(iii) Haz una función que calcule un tiempo de primer paso." 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": {}, 286 | "outputs": [], 287 | "source": [] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "(iv) Haz una función que calcule el tiempo medio de primer paso, $\\langle \\tau \\rangle$, promediado sobre algunas trayectorias." 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": null, 299 | "metadata": {}, 300 | "outputs": [], 301 | "source": [] 302 | }, 303 | { 304 | "cell_type": "markdown", 305 | "metadata": {}, 306 | "source": [ 307 | "(v) Calcula y dibuja $\\langle \\tau \\rangle(L)$ como función de la longitud $L$ de la caja, para valores no demasiado grandes de $L$. ¿Cómo se comporta?" 308 | ] 309 | }, 310 | { 311 | "cell_type": "code", 312 | "execution_count": null, 313 | "metadata": {}, 314 | "outputs": [], 315 | "source": [] 316 | }, 317 | { 318 | "cell_type": "markdown", 319 | "metadata": {}, 320 | "source": [ 321 | "(vi) Extrapolando, predice el valor de $\\tau$ cuando $L \\to \\infty$, es decir si no hay frontera de la caja." 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": 6, 327 | "metadata": {}, 328 | "outputs": [], 329 | "source": [] 330 | }, 331 | { 332 | "cell_type": "markdown", 333 | "metadata": {}, 334 | "source": [ 335 | "(vii) Para entender mejor este resultado, dibuja la distribución de probabilidad de $\\tau(L)$ para $L=20$. ¿Cómo se comporta la \"cola\" de la distribución, es decir para valores grandes de $\\tau$? [Pista: Necesitarás al menos 10^6 corridas. Dibuja el resultado de otra forma si sea necesario.]" 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": null, 341 | "metadata": {}, 342 | "outputs": [], 343 | "source": [] 344 | } 345 | ], 346 | "metadata": { 347 | "kernelspec": { 348 | "display_name": "Julia 1.0.3", 349 | "language": "julia", 350 | "name": "julia-1.0" 351 | }, 352 | "language_info": { 353 | "file_extension": ".jl", 354 | "mimetype": "application/julia", 355 | "name": "julia", 356 | "version": "1.0.3" 357 | } 358 | }, 359 | "nbformat": 4, 360 | "nbformat_minor": 2 361 | } 362 | -------------------------------------------------------------------------------- /notebooks/08. Raices de funciones uni-dimensionales.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Raíces de funciones uni-dimensionales" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En este notebook, investigaremos algunos algoritmos para encontrar **raíces** de funciones uni-dimensionales, utilizando métodos iterativos. Esto es un problema que ocurre por todos lados en la física, por ejemplo para el pozo cuadrado en mecánica cuántica, o para encontrar el valor máximo de una función.\n", 15 | "\n", 16 | "Recuerda que $x^*$ es una raíz (o cero) de la función $f$ si $f(x^*) = 0$. Como sabemos, en general las raíces de una función no se pueden encontrar de manera analítica, excepto para funciones $f$ que sean polinomios de grado $\\le 4$.\n", 17 | "\n", 18 | "Por lo tanto, para encontrar raíces tendremos que utilizar algoritmos iterativos.\n", 19 | "Recuerda que un algoritmo iterativo tiene la forma general\n", 20 | "\n", 21 | "$$x_{n+1} := f(x_n),$$\n", 22 | "\n", 23 | "y consiste en comenzar en una *adivinianza* inicial $x_0$ y generar una secuencia $x_1 := f(x_0)$; $x_2 := f(x_1)$, etc.\n", 24 | "Si diseñamos correctamente el algoritmo, la esperanza es que la secuencia $(x_n)_{n=1}^\\infty$ converja a alguna raíz $x^*$ con $f(x^*) = 0$, es decir que $f(x_n) \\to 0$ cuando $n \\to \\infty$." 25 | ] 26 | }, 27 | { 28 | "cell_type": "markdown", 29 | "metadata": {}, 30 | "source": [ 31 | "Dado que no podemos llevar a cabo la iteración un número infinito de veces, se corta la iteración después de un cierto número de pasos, para dar una solución *aproximada*, que se encuentra dentro de cierta *tolerancia* del resultado teórico exacto $x^*$. Por lo tanto, cualquier algoritmo iterativo requiere una condición de terminación." 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "Ya hemos visto que a veces podemos encontrar soluciones de ecuaciones (que equivalen a raíces de funciones) al reescribir la función para resolverla de forma iterativa directamente. Sin embargo, lo que nos interesa es tener una forma más general de encontrar raíces de cualquier ecuación." 39 | ] 40 | }, 41 | { 42 | "cell_type": "markdown", 43 | "metadata": {}, 44 | "source": [ 45 | "# Raíces de funciones: Bisección" 46 | ] 47 | }, 48 | { 49 | "cell_type": "markdown", 50 | "metadata": {}, 51 | "source": [ 52 | "Un primer método para encontrar una raíz es el **método de bisección**.\n", 53 | "Dada una función continua $f$, una condición suficiente (pero no necesaria) para que *exista* una raiz en un intervalo dado $[a, b]$ es que $F$ cambie de signo en el intervalo, es decir, que $f(a)$ y $f(b)$ tengan signos opuestos. Si esto ocurre, entonces el teorema del valor intermedio nos dice que $f$ tiene (al menos) una raíz en $[a, b]$." 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "#### Ejercicio 1\n", 61 | "\n", 62 | "La idea del método de bisección es adivinar que el punto medio del intervalo $[a, b]$ sea una primera aproximación para la raíz. Escribamos una función `bisección` que implemente este método, que toma como argumento la función $f$ y los extremos `a` y `b`.\n", 63 | "\n", 64 | "(i) Define una función `punto_medio` que tome $a$ y $b$ y calcule el punto medio entre ellos. Verifica que tu definición sea correcto en algunos casos." 65 | ] 66 | }, 67 | { 68 | "cell_type": "code", 69 | "execution_count": null, 70 | "metadata": {}, 71 | "outputs": [], 72 | "source": [] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "(ii) Sea $c$ el punto medio de $[a, b]$. Esto divide el intervalo original en dos partes. Es posible (aunque improbable) que $c$ ya es la raíz, en cuyo caso ya podemos terminar la función y regresar la raíz que hemos encontrado. ¿Cómo se checa si ya es la raíz? Si no, ¿cómo podemos saber en cuál de los dos sub-intervalos cae la raíz? Impleméntalo. " 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": null, 84 | "metadata": {}, 85 | "outputs": [], 86 | "source": [] 87 | }, 88 | { 89 | "cell_type": "markdown", 90 | "metadata": {}, 91 | "source": [ 92 | "(iii) Define un algoritmo iterativo al repitir estos pasos hasta que encuentres la raíz con cierta tolerancia. [Pista: Para la siguiente vuelta del bucle, deberás tener un nuevo intervalo `[a, b]`.\n", 93 | "Puedes utilizar una expresión de la forma `(e, f) = (g, h)` para copiar el valor de `g` a la variable `e` y el valor de `h` a la variable `f`.]" 94 | ] 95 | }, 96 | { 97 | "cell_type": "code", 98 | "execution_count": null, 99 | "metadata": {}, 100 | "outputs": [], 101 | "source": [] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "(iv) La función debe regresar la raíz que encontró, así como un vector de todos los iterados." 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": null, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "#### Ejercicio 2\n", 122 | "\n", 123 | "(i) Aplica tu función `bisección` para encontrar la raíz cuadrada positiva de $2$. Para hacerlo, tendrás que escoger (a mano) intervalos iniciales que cumplan con la condición de cambio de signo. " 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "(ii) Define la distancia $d_n := x_n - x^*$, donde $x^*$ es la raíz. Dibuja $d_n$ como función del paso $n$. ¿Qué tan rápidamente converge $d_n$ a $0$? [Pista: Dibuja la gráfica con distintos tipos de escalas para entender la forma funcional de la convergencia.]" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "(iii) Encuentra la solución de la ecuación $\\sin(x) = x$ utilizando bisección. ¿Qué tan rápidamente se acercan los iterados $x_n$ a la solución en este caso?" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "# El algoritmo Babilónico" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "Un ejemplo de un algoritmo sorprendente es el *algoritmo Babilónico* (o de Herón) para calcular la raiz cuadrada $\\sqrt{y}$ de un número real $y$. Una forma de este algoritmo se utiliza a menudo para calcular la raíz cuadrada en las computadoras.\n", 173 | "\n", 174 | "Para un algoritmo, siempre necesitamos una *idea*, que toma una adivinanza $x_n$ y produce una (probablemente) mejor, $x_{n+1}$. La idea del algoritmo Babilónico es la siguiente." 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "#### Ejercicio 3\n", 182 | "\n", 183 | "(i) ¿De cuál ecuación en $x$ es raíz el número $x^* = \\sqrt{y}$? ¿Cuál otra solución de esta ecuación hay?" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": null, 189 | "metadata": {}, 190 | "outputs": [], 191 | "source": [] 192 | }, 193 | { 194 | "cell_type": "markdown", 195 | "metadata": {}, 196 | "source": [ 197 | "(ii) Dada una adivinanza $x_n$, es posible (pero improbable) que $x_n$ ya sea exactamente $\\sqrt{y}$. ¿Cómo lo puedes verificar, sin utilizar (por supuesto) alguna función en Julia que calcule la raíz cuadrada? Escribe el código correspondiente." 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "metadata": {}, 204 | "outputs": [], 205 | "source": [] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "(iii) Si $x_n$ no es raíz, demuestra con papel que $\\frac{y}{x_n}$ se encuentra *del lado opuesto de $\\sqrt{y}$ que $x_n$* sobre la recta real. [Pista: Hay dos casos que considerar.]" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": null, 217 | "metadata": {}, 218 | "outputs": [], 219 | "source": [] 220 | }, 221 | { 222 | "cell_type": "markdown", 223 | "metadata": {}, 224 | "source": [ 225 | "(iv) Así, tenemos dos valores que se encuentran por dos lados diferentes de $\\sqrt{y}$. ¿Cuál sería una mejor adivinanza para $x_{n+1}$? Impleméntalo." 226 | ] 227 | }, 228 | { 229 | "cell_type": "code", 230 | "execution_count": null, 231 | "metadata": {}, 232 | "outputs": [], 233 | "source": [] 234 | }, 235 | { 236 | "cell_type": "markdown", 237 | "metadata": {}, 238 | "source": [ 239 | "(v) Utiliza esta idea para escribir una función que calcule $\\sqrt{y}$ para una $y$ dada." 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": null, 245 | "metadata": {}, 246 | "outputs": [], 247 | "source": [] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "(vi) ¿Qué tan rápido converge a la raíz cuadrada? Grafícalo. ¿Cómo se compara con el método de bisección?" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": null, 259 | "metadata": {}, 260 | "outputs": [], 261 | "source": [] 262 | } 263 | ], 264 | "metadata": { 265 | "kernelspec": { 266 | "display_name": "Julia 1.0.3", 267 | "language": "julia", 268 | "name": "julia-1.0" 269 | }, 270 | "language_info": { 271 | "file_extension": ".jl", 272 | "mimetype": "application/julia", 273 | "name": "julia", 274 | "version": "1.0.3" 275 | } 276 | }, 277 | "nbformat": 4, 278 | "nbformat_minor": 1 279 | } 280 | -------------------------------------------------------------------------------- /notebooks/10. Diferencias finitas.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Diferencias finitas: cálculo numérico de derivadas" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En el último notebook, vimos que el método de Newton requiere utilizar la derivada de una función.\n", 15 | "En este notebook, veremos una manera (no necesariamente la mejor) de calcular derivadas de funciones de forma numérica: **diferencias finitas**." 16 | ] 17 | }, 18 | { 19 | "cell_type": "markdown", 20 | "metadata": {}, 21 | "source": [ 22 | "## Derivadas de funciones uni-dimensionales" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "#### Ejercicio 1\n", 30 | "\n", 31 | "Considera una función uni-dimensional $f: \\mathbb{R} \\to \\mathbb{R}$, y supón que sea suficientemente diferenciable para que las derivadas que tomemos estén definidas [por ejemplo, si $f$ es de clase $C^2$].\n", 32 | "\n", 33 | "(i) Escribe, usando notación LaTeX, la definición de la derivada $f'(a)$ de $f$ en el punto $a$, como límite cuando la variable $h$ tiende a $0$." 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "Desgraciadamente, **no podemos llevar a cabo el proceso de límite en la computadora**: un límite es algo **continuo**, mientras que la computadora maneja cantidades **discretas**.\n", 48 | "\n", 49 | "(ii) ¿Cuál solución se te ocurre para esto en términos de la variable $h$? " 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": null, 55 | "metadata": {}, 56 | "outputs": [], 57 | "source": [] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "La expresión $f(a+h) - f(a)$ se llama una **diferencia para adelante** (\"forward difference\"), y cuando lo dividimos por un valor fijo de $h$ se llama un **cociente de diferencias** (\"difference quotient\"). Pero todo junto tambien se llama una diferencia finita.\n", 64 | "\n", 65 | "(iii) ¿Geométricamente, a qué corresponde una diferencia de este tipo? ¿Y un cociente de diferencias?" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "#### Ejercicio 2\n", 80 | "\n", 81 | "(i) Escribe una función que implemente una diferencia para adelante para una función $f$, punto $a$ y paso $h$ dadas." 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": null, 87 | "metadata": {}, 88 | "outputs": [], 89 | "source": [] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "(ii) Para distintas funciones $f$, grafica la función $f$, su derivada analítica $f'$, y la aproximación a $f'$ utilizando diferencias finitas con distintos pasos $h$." 96 | ] 97 | }, 98 | { 99 | "cell_type": "code", 100 | "execution_count": null, 101 | "metadata": {}, 102 | "outputs": [], 103 | "source": [] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "(iii) Calcula el error desde el valor analítico que se comete al utilizar la aproximación de la derivada al tomar una $f$ y $a$ dadas, y al variar $h$.\n", 110 | "Puedes espaciar los valores de $h$ de forma logarítmica. Hazlo para diferentes funciones y para valores de $h$ tan chicos como $10^{-15}$. (¡Escribe una función que haga el cálculo!) ¿Qué observas? ¿Qué podría causar este efecto?" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "(iv) ¿Para qué clase de funciones será el resultado exacto? Demuéstralo gráficamente. Así, ¿qué tipo de **aproximación local** de la función estamos usando implícitamente? " 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "#### Ejercicio 3 \n", 139 | "\n", 140 | "(i) Desarrolla $f(a + h)$ en una serie de Taylor con término complementario de Lagrange. Así, rederiva la expresión aproximada que ya obtuviste para la derivada, pero ahora con información *analítica* sobre **el tamaño del error** que cometes cuando utilizas esta aproximación (asintóticamente cuando $h \\to 0$). Si el error va como $C.h^n$, con $C$ una constante, entonces escribimos $\\mathcal{O}(h^n)$. " 141 | ] 142 | }, 143 | { 144 | "cell_type": "code", 145 | "execution_count": null, 146 | "metadata": {}, 147 | "outputs": [], 148 | "source": [] 149 | }, 150 | { 151 | "cell_type": "markdown", 152 | "metadata": {}, 153 | "source": [ 154 | "(ii) Verifica que coinicide con lo que encontraste numéricamente." 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | }, 164 | { 165 | "cell_type": "markdown", 166 | "metadata": {}, 167 | "source": [ 168 | "#### Ejercicio 4\n", 169 | "\n", 170 | "(i) Una mejor aproximación (¿a qué nos referimos con eso?) es la **diferencia centrada**: desarrolla $f(a+h)$ y $f(a - h)$ en series de Taylor separadas. Así, deriva una mejor aproximación a la primera derivada. Calcula su error y chécalo numéricamente. ¿Para qué tipo de funciones es exacta? " 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "(ii) Encuentra una aproximación para la segunda derivada y encuentra su error; chécalo numéricamente. " 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": {}, 191 | "outputs": [], 192 | "source": [] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "## Funciones multi-dimensionales " 199 | ] 200 | }, 201 | { 202 | "cell_type": "markdown", 203 | "metadata": {}, 204 | "source": [ 205 | "Ahora consideremos una función $f: \\mathbb{R}^2 \\to \\mathbb{R}$ y $g: \\mathbb{R}^2 \\to \\mathbb{R}^2$." 206 | ] 207 | }, 208 | { 209 | "cell_type": "markdown", 210 | "metadata": {}, 211 | "source": [ 212 | "#### Ejercicio 5\n", 213 | "\n", 214 | "(i) ¿Qué tipo de derivadas quisiéramos poder calcular para $f$ y $g$? ¿Cómo podemos utilizar lo que ya hicimos para funciones uni-dimensionales para aplicarlo directamente a $f$ y $g$?" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "(ii) Impleméntalo y compara con funciones cuyas derivadas conoces analíticamente." 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "## De regreso al método de Newton" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "#### Ejercicio 6\n", 250 | "\n", 251 | "Utiliza una diferencia finita, con una $h$ pequeña, para aproximar la derivada en el método de Newton. ¿Cómo afecta el utilizar una aproximación de la derivada, en lugar del valor exacto, en la tasa de convergencia? Compara los resultados al utilizar los dos tipos de diferencias finitas (para adelante y centrada)." 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": {}, 258 | "outputs": [], 259 | "source": [] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "## Diferencias finitas con pasos complejos" 266 | ] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": {}, 271 | "source": [ 272 | "\n", 273 | "\n", 274 | "Una alternativa interesante es el utilizar la fórmula\n", 275 | "\n", 276 | "$$f'(a) \\simeq \\frac{\\mathrm{Im}[f(a + ih)]}{h},$$\n", 277 | "\n", 278 | "donde $i=\\sqrt{-1}$ y utilizamos evaluaciones complejas de la función real $f$; $\\mathrm{Im}$ denota la parte imaginaria." 279 | ] 280 | }, 281 | { 282 | "cell_type": "markdown", 283 | "metadata": {}, 284 | "source": [ 285 | "#### Ejercicio 7\n", 286 | "\n", 287 | "(i) Implementa esto y verifica que puedes utilizar valores de $h$ ridículamente pequeñas." 288 | ] 289 | }, 290 | { 291 | "cell_type": "code", 292 | "execution_count": null, 293 | "metadata": {}, 294 | "outputs": [], 295 | "source": [] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": {}, 300 | "source": [ 301 | "(ii) Encuentra el tamaño del error numérico en función de $h$." 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [] 310 | }, 311 | { 312 | "cell_type": "markdown", 313 | "metadata": {}, 314 | "source": [ 315 | "(iii) Utiliza un desarrollo de Taylor para encontrar el tamaño del error." 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": null, 321 | "metadata": {}, 322 | "outputs": [], 323 | "source": [] 324 | } 325 | ], 326 | "metadata": { 327 | "kernelspec": { 328 | "display_name": "Julia 1.0.3", 329 | "language": "julia", 330 | "name": "julia-1.0" 331 | }, 332 | "language_info": { 333 | "file_extension": ".jl", 334 | "mimetype": "application/julia", 335 | "name": "julia", 336 | "version": "1.0.3" 337 | } 338 | }, 339 | "nbformat": 4, 340 | "nbformat_minor": 2 341 | } 342 | -------------------------------------------------------------------------------- /notebooks/20. Sistemas de ecuaciones lineales.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Sistemas de ecuaciones lineales" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En el notebook anterior, vimos que un problema de valores en la frontera, por ejemplo, el problema de Poisson, se puede expresar como un sistema de ecuaciones lineales, y, por lo tanto, se puede escribir en forma matricial como\n", 15 | "\n", 16 | "$$ \\mathsf{A} \\cdot \\mathbf{V} = \\mathbf{b},$$\n", 17 | "\n", 18 | "donde $\\mathbf{V} = (V_0, \\ldots, V_L)$ son los valores desconocidos del potencial, $\\mathsf{A}$ es una matriz proveniente de la discretización del Laplaciano usando diferencias finitas, y $\\mathbf{b}$ es un vector que combina el potencial y las condiciones en la frontera." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "En el notebook anterior, utilizamos un método **iterativo** para resolver este sistema, pero vimos que converge lentamente a la solución. \n", 26 | "\n", 27 | "En este notebook, veremos un método **directo** (es decir, no iterativo, y que requiere un número de pasos finito para terminar el cálculo) para resolver sistemas de ecuaciones lineales, el método de **eliminación gaussiana**, que seguramente ya vieron en Álgebra Lineal." 28 | ] 29 | }, 30 | { 31 | "cell_type": "markdown", 32 | "metadata": {}, 33 | "source": [ 34 | "## Eliminación gaussiana" 35 | ] 36 | }, 37 | { 38 | "cell_type": "markdown", 39 | "metadata": {}, 40 | "source": [ 41 | "Considera el sistema de ecuaciones lineales\n", 42 | "\n", 43 | "$$ \\mathsf{A} \\cdot \\mathbf{x} = \\mathbf{b}. \\qquad (1)$$\n", 44 | "\n", 45 | "Aquí, $\\mathsf{A}$ es una matriz cuadrada dada, de tamaño $n \\times n$, y $\\mathbf{b}$ es un vector dado en $\\mathbb{R}^n$. Queremos resolver esta ecuación para encontrar el vector desconocido $\\mathbf{x} \\in \\mathbb{R}^n$.\n", 46 | "\n", 47 | "Recuerda que podemos resolver este sistema utilizando el método de eliminación gaussiana, que consiste en llevar a cabo **operaciones de renglón**, tanto para la matriz $\\mathsf{A}$ como el vector $\\mathbf{b}$, para reducir $\\mathsf{A}$ a una forma triangular.\n", 48 | "\n", 49 | "[En este notebook, debes implementar los métodos numéricos \"a mano\" en la computadora, sin utilizar ningún método ni paquete de Julia ya implementado.]" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "#### Ejercicio 1\n", 57 | "\n", 58 | "Re-escribe la ecuación (1) utilizando índices y sumas." 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "metadata": {}, 65 | "outputs": [], 66 | "source": [] 67 | }, 68 | { 69 | "cell_type": "markdown", 70 | "metadata": {}, 71 | "source": [ 72 | "#### Ejercicio 2\n", 73 | "\n", 74 | "Considera la ecuación $\\mathsf{U} \\cdot \\mathbf{x} = \\mathbf{c}$, en la cual $\\mathsf{U}$ es una matriz triangular superior (\"*U*pper triangular\").\n", 75 | "\n", 76 | "(i) ¿Cuál es la condición para que una matriz $\\mathsf{A}$ sea triangular superior, en términos de sus entradas $A_{ij}$? " 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": null, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "(ii) ¿Cómo se puede resolver esta ecuación? Piensa primero en un caso chiquito, e.g. $3 \\times 3$ con entradas $U_{11}$ etc., para que puedas hacer todo explícitamente." 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": null, 96 | "metadata": {}, 97 | "outputs": [], 98 | "source": [] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "(iii) Implementa este método para una matriz triangular superior arbitraria. (Supón que la matriz ya tenga esta forma.)" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": null, 110 | "metadata": {}, 111 | "outputs": [], 112 | "source": [] 113 | }, 114 | { 115 | "cell_type": "markdown", 116 | "metadata": {}, 117 | "source": [ 118 | "(iv) Verifica que tu método numérico funciona, es decir ¡que el resultado sí sea solución de la ecuación original!" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [] 127 | }, 128 | { 129 | "cell_type": "markdown", 130 | "metadata": {}, 131 | "source": [ 132 | "#### Ejercicio 3\n", 133 | "\n", 134 | "(i) Escribe, a mano, el método de eliminación gaussiana para reducir una matriz de $2 \\times 2$ a una matriz triangular superior, en términos de operaciones de renglón. ¿Qué se debe hacer al lado derecho de la ecuación? Supón (por el momento) que no hay problemas con dividir por cero. " 135 | ] 136 | }, 137 | { 138 | "cell_type": "code", 139 | "execution_count": null, 140 | "metadata": {}, 141 | "outputs": [], 142 | "source": [] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "(ii) Impleméntalo numéricamente. Utiliza tu código para resolver el sistema de ecuaciones lineales\n", 149 | "\n", 150 | "\\begin{align} \n", 151 | " 3x + 7y &= 1; \\\\\n", 152 | " 2x + 4y &= 1.\n", 153 | "\\end{align}\n", 154 | "\n", 155 | "Por supuesto, ¡debes verificar que la solución que encuentres realmente sí sea solución de la ecuación!" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": null, 161 | "metadata": {}, 162 | "outputs": [], 163 | "source": [] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": {}, 168 | "source": [ 169 | "#### Ejercicio 4\n", 170 | "\n", 171 | "(i) Implementa el método de eliminación gaussiana para reducir una matriz arbitraria a una matriz triangular superior, suponiendo que no ocurra ningún caso problemático (0 en el lugar del pivot)." 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "(ii) Utiliza lo que ya has hecho para resolver un sistema lineal general [pero todavía suponiendo que no haya divisiones entre 0]." 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": {}, 198 | "source": [ 199 | "(iii) Utiliza tu código para resolver el sistema\n", 200 | "\n", 201 | "\\begin{align}\n", 202 | " 2x + y - z &= 8; \\\\\n", 203 | " -3x - y + 2z &= -11; \\\\\n", 204 | " -2x + y + 2x &= -3.\n", 205 | "\\end{align}" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": null, 211 | "metadata": {}, 212 | "outputs": [], 213 | "source": [] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "#### Ejercicio 5\n", 220 | "\n", 221 | "(i) El acto de llevar a cabo una operación de renglón (como las que se utilizan en la eliminación gaussiana) sobre una matriz $\\mathsf{A}$ se puede escribir como una multiplicación de $\\mathsf{A}$ con otra matriz $\\mathsf{L}$. ¿Cuál matriz $\\mathsf{L}$? ¿Qué propiedad tiene $\\mathsf{L}$?" 222 | ] 223 | }, 224 | { 225 | "cell_type": "code", 226 | "execution_count": null, 227 | "metadata": {}, 228 | "outputs": [], 229 | "source": [] 230 | }, 231 | { 232 | "cell_type": "markdown", 233 | "metadata": {}, 234 | "source": [ 235 | "(ii) Considerando que el método de eliminación gaussiana consiste en una secuencia de operaciones de renglón, que son multiplicaciones por matrices $L_j$, y que produce una matriz triangular superior $U$, ¿cómo se puede escribir $U$ en términos de las $L_j$?" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": null, 241 | "metadata": {}, 242 | "outputs": [], 243 | "source": [] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "(iii) Por lo tanto, ¿de qué forma se puede escribir $\\mathsf{A}$? " 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": null, 255 | "metadata": {}, 256 | "outputs": [], 257 | "source": [] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "(iv) ¿Qué implica esto si un problema consiste en resolver muchas ecuaciones de la forma $\\mathsf{A} \\cdot \\mathbf{x}^{(i)} = \\mathbf{b}^{(i)}$, para distintos lados derechos $\\mathbf{b}^{(i)}$?" 264 | ] 265 | }, 266 | { 267 | "cell_type": "code", 268 | "execution_count": null, 269 | "metadata": {}, 270 | "outputs": [], 271 | "source": [] 272 | }, 273 | { 274 | "cell_type": "markdown", 275 | "metadata": {}, 276 | "source": [ 277 | "#### Ejercicio 6 \n", 278 | "\n", 279 | "Utiliza tu función que resuelve sistemas de ecuaciones lineales para implementar el método de Newton en varias dimensiones.\n", 280 | "\n", 281 | "Como ejemplo, resuelve el siguiente sistema de ecuaciones no-lineales:\n", 282 | "\n", 283 | "$$x^2 + y^2 = 1$$\n", 284 | "$$x + y = 1.$$\n", 285 | "\n", 286 | "¿Cuántas soluciones tiene? Compara con la solución analítica." 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [] 295 | } 296 | ], 297 | "metadata": { 298 | "kernelspec": { 299 | "display_name": "Julia 1.0.3", 300 | "language": "julia", 301 | "name": "julia-1.0" 302 | }, 303 | "language_info": { 304 | "file_extension": ".jl", 305 | "mimetype": "application/julia", 306 | "name": "julia", 307 | "version": "1.0.3" 308 | }, 309 | "toc": { 310 | "colors": { 311 | "hover_highlight": "#DAA520", 312 | "running_highlight": "#FF0000", 313 | "selected_highlight": "#FFD700" 314 | }, 315 | "moveMenuLeft": true, 316 | "nav_menu": { 317 | "height": "49px", 318 | "width": "252px" 319 | }, 320 | "navigate_menu": true, 321 | "number_sections": true, 322 | "sideBar": true, 323 | "threshold": "2", 324 | "toc_cell": false, 325 | "toc_section_display": "block", 326 | "toc_window_display": false 327 | } 328 | }, 329 | "nbformat": 4, 330 | "nbformat_minor": 1 331 | } 332 | -------------------------------------------------------------------------------- /notebooks/04. Caminatas aleatorias.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Caminatas aleatorias" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En este notebook, empezaremos a explorar la modelación de una **caminata aleatoria**, o sea el **movimiento Browniano** -- un movimiento aleatorio de una partícula moviéndose en un fluido. Llevaremos a cabo una primera simulación computacional de este sistema. " 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "## Modelaje\n", 22 | "\n", 23 | "Para hacer un modelo matemático / computacional de un sistema físico, siempre es necesario hacer unas simplificaciones.\n", 24 | "Para empezar a modelar una partícula en un fluido, haremos unas simplificaciones bastante drásticas:\n", 25 | "\n", 26 | "- En lugar de modelar el fluido, modelaremos el fluido a través de impactos **aleatorios** sobre la partícula. \n", 27 | "\n", 28 | "\n", 29 | "- Supondremos (aunque no es nada realista) que los impactos causen que la partícula dé brincos en el espacio.\n", 30 | "\n", 31 | "\n", 32 | "- Supondremos que los impactos occurran en tiempos espaciados de forma regular, así que podemos hablar de pasos de tiempo.\n", 33 | "\n", 34 | "\n", 35 | "- Supondremos que la partícula brinque la misma distancia en cada pasito, y que vive en una red.\n", 36 | "\n", 37 | "Por supuesto, todas estas restricciones se pueden quitar después." 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "## Números aleatorios" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": {}, 50 | "source": [ 51 | "Julia tiene una función `rand` para generar cosas aleatorias (\"*rand*om\", en inglés).\n", 52 | "Esta función tiene distintas variantes para generar distintos tipos de objetos aleatorios." 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "#### Ejercicio 1\n", 60 | "(i) Ejecuta la función `rand` varias veces, para adivinar qué es lo que está produciendo." 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "(ii) Ahora pon `rand(Bool)` varias veces. ¿Qué es lo que genera? Nota que `Bool` quiere decir una variable *Bool*eana." 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "(iii) ¿Qué pasa si pones `rand(n)` con algún número `n` adentro?" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": null, 94 | "metadata": {}, 95 | "outputs": [], 96 | "source": [] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "## Caminatas aleatorias" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "El modelo más sencillo consiste en una **caminata aleatoria**; en la versión más sencilla, una partícula se mueve en una dimensión y vive en los enteros, haciendo brincos a la izquierda con probabilidad $\\frac{1}{2}$, y a la derecha con probabilidad $\\frac{1}{2}$." 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "¿Qué necesitaremos para *programar* una caminata aleatoria en la computadora? Ya hemos visto como generar un `Bool` aleatorio. Pero necesitamos más bien un *brinco* aleatorio, como sigue." 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "### Ejercicio 2\n", 124 | "\n", 125 | "(i) Define una variable `r` que es igual al resultado de `rand(Bool)`. Conviértelo a un número entero `s`, usando la función `Int`. (Entero en inglés es \"*int*eger\".) [Nota que en Julia, sí importa si los nombres se escriben con mayúsculas o minúsculas.]" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": {}, 132 | "outputs": [], 133 | "source": [] 134 | }, 135 | { 136 | "cell_type": "markdown", 137 | "metadata": {}, 138 | "source": [ 139 | "(ii) ¿Cuáles valores puede tomar `s`?" 140 | ] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": null, 145 | "metadata": {}, 146 | "outputs": [], 147 | "source": [] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "(ii) Para una caminata aleatoria, necesitamos brincos de tamaño $1$ o $-1$. Cómo puedes utilizar aritmética para generar un brinco $\\Delta$ a partir de `s`? " 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "#### Ejercicio 3\n", 168 | "\n", 169 | "Ahora hagamos nuestra primera simulación, de una caminata aleatoria.\n", 170 | "\n", 171 | "(i) Define una función `caminata` que tome un argumento `n` y simule una caminata aleatoria de `n` pasos. Escribe la posición en cada paso en la pantalla." 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": null, 177 | "metadata": {}, 178 | "outputs": [], 179 | "source": [] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "metadata": {}, 184 | "source": [ 185 | "(ii) En lugar de imprimir las posiciones, guárdalas en un vector y regresa el vector de la función." 186 | ] 187 | }, 188 | { 189 | "cell_type": "code", 190 | "execution_count": null, 191 | "metadata": {}, 192 | "outputs": [], 193 | "source": [] 194 | }, 195 | { 196 | "cell_type": "markdown", 197 | "metadata": {}, 198 | "source": [ 199 | "### Guardar los datos" 200 | ] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "#### Ejercicio 4\n", 207 | "\n", 208 | "(i) Guarda los datos que se generaron con \n", 209 | "\n", 210 | "```\n", 211 | "using DelimitedFiles # paquete para escribir y leer datos\n", 212 | "writedlm(\"archivo.dat\", v)\n", 213 | "```\n", 214 | "donde el primer argumento es el nombre del archivo que escribir, y `v` es la variable que escribir. " 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "(ii) Utiliza `readdlm` para leer el archivo y guardar el resultado en una variable llamada `nuevo`." 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "### Visualización" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "Ahora visualicemos las trayectorias de unos caminantes." 250 | ] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "#### Ejercicio 5\n", 257 | "\n", 258 | "(i) Crea un camino `camino1` con 10 pasos. " 259 | ] 260 | }, 261 | { 262 | "cell_type": "code", 263 | "execution_count": null, 264 | "metadata": {}, 265 | "outputs": [], 266 | "source": [] 267 | }, 268 | { 269 | "cell_type": "markdown", 270 | "metadata": {}, 271 | "source": [ 272 | "(ii) Dibújalo." 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": null, 278 | "metadata": {}, 279 | "outputs": [], 280 | "source": [] 281 | }, 282 | { 283 | "cell_type": "markdown", 284 | "metadata": {}, 285 | "source": [ 286 | "(iii) Pon también puntos utilizando el \"argumento de palabra clave\" `m='o'` adentro del comando de `plot`." 287 | ] 288 | }, 289 | { 290 | "cell_type": "code", 291 | "execution_count": null, 292 | "metadata": {}, 293 | "outputs": [], 294 | "source": [] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": {}, 299 | "source": [ 300 | "(iv) Dibuja únicamente los puntos al utilizar `scatter` en lugar de `plot`." 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": null, 306 | "metadata": {}, 307 | "outputs": [], 308 | "source": [] 309 | }, 310 | { 311 | "cell_type": "markdown", 312 | "metadata": {}, 313 | "source": [ 314 | "(v) Crea y dibuja 5 caminos en la misma gráfica, utilizando `plot!` (con `!` al final) para agregar elementos a un dibujo pre-existente." 315 | ] 316 | }, 317 | { 318 | "cell_type": "code", 319 | "execution_count": null, 320 | "metadata": {}, 321 | "outputs": [], 322 | "source": [] 323 | }, 324 | { 325 | "cell_type": "markdown", 326 | "metadata": {}, 327 | "source": [ 328 | "#### Ejercicio 6\n", 329 | "\n", 330 | "Ahora podemos empezar a ver cosas interesantes.\n", 331 | "\n", 332 | "(i) Utiliza un bucle `for` para dibujar 100 caminos con 100 pasos cada uno. Para hacerlo, primero crea un `plot` vacío con el nombre `p` y sin leyenda (`leg=false`). Luego dibuja los caminantes. Al final, muestra el objeto `p`." 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": null, 338 | "metadata": {}, 339 | "outputs": [], 340 | "source": [] 341 | }, 342 | { 343 | "cell_type": "markdown", 344 | "metadata": {}, 345 | "source": [ 346 | "(ii) ¿Qué observas? ¿Cómo parece crecer la nube de caminantes en el tiempo? ¿Cómo podrías pensar en averiguar eso numéricamente? **Opcional: ¡Hazlo!" 347 | ] 348 | }, 349 | { 350 | "cell_type": "code", 351 | "execution_count": null, 352 | "metadata": {}, 353 | "outputs": [], 354 | "source": [] 355 | }, 356 | { 357 | "cell_type": "markdown", 358 | "metadata": {}, 359 | "source": [ 360 | "(iii) En la gráfica, los caminos se sobreponen, así que no se puede ver cuántos caminantes pasaron por un punto dado en cada paso. En un paso dado, ¿qué harías para ver esto? **Opcional: ¡Hazlo!" 361 | ] 362 | }, 363 | { 364 | "cell_type": "code", 365 | "execution_count": null, 366 | "metadata": {}, 367 | "outputs": [], 368 | "source": [] 369 | } 370 | ], 371 | "metadata": { 372 | "kernelspec": { 373 | "display_name": "Julia 1.0.3", 374 | "language": "julia", 375 | "name": "julia-1.0" 376 | }, 377 | "language_info": { 378 | "file_extension": ".jl", 379 | "mimetype": "application/julia", 380 | "name": "julia", 381 | "version": "1.0.3" 382 | } 383 | }, 384 | "nbformat": 4, 385 | "nbformat_minor": 1 386 | } 387 | -------------------------------------------------------------------------------- /notebooks/Introduccion.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": { 6 | "slideshow": { 7 | "slide_type": "slide" 8 | } 9 | }, 10 | "source": [ 11 | "# Física Computacional 2019-3\n", 12 | "\n", 13 | "### Departamento de Física, Facultad de Ciencias, UNAM" 14 | ] 15 | }, 16 | { 17 | "cell_type": "markdown", 18 | "metadata": { 19 | "slideshow": { 20 | "slide_type": "fragment" 21 | } 22 | }, 23 | "source": [ 24 | "## Datos del curso\n", 25 | "\n", 26 | "- Profesor: Dr. David P. Sanders\n", 27 | "\n", 28 | "- Ayudante: Crhistian Benítez" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": { 34 | "slideshow": { 35 | "slide_type": "slide" 36 | } 37 | }, 38 | "source": [ 39 | "## Meta del curso" 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": { 45 | "slideshow": { 46 | "slide_type": "fragment" 47 | } 48 | }, 49 | "source": [ 50 | "- Aprender cómo podemos utilizar la computadora como **herramienta** para la física" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "- Aprender los elementos fundamentales de la programación con el lenguaje **Julia**" 58 | ] 59 | }, 60 | { 61 | "cell_type": "markdown", 62 | "metadata": { 63 | "slideshow": { 64 | "slide_type": "fragment" 65 | } 66 | }, 67 | "source": [ 68 | "- Estudiar algunos métodos numéricos claves y su implementación" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": { 74 | "slideshow": { 75 | "slide_type": "fragment" 76 | } 77 | }, 78 | "source": [ 79 | "- ¡No temerle a la computadora, ni a la programación!" 80 | ] 81 | }, 82 | { 83 | "cell_type": "markdown", 84 | "metadata": { 85 | "slideshow": { 86 | "slide_type": "slide" 87 | } 88 | }, 89 | "source": [ 90 | "## ¿Qué es Julia?" 91 | ] 92 | }, 93 | { 94 | "cell_type": "markdown", 95 | "metadata": { 96 | "slideshow": { 97 | "slide_type": "fragment" 98 | } 99 | }, 100 | "source": [ 101 | "- Lenguaje de programación general\n", 102 | "\n", 103 | "\n", 104 | "- Diseñado para que sea ideal para el cómputo científico / ciencia computacional\n", 105 | "\n", 106 | "\n", 107 | "- http://www.julialang.org\n" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": { 113 | "slideshow": { 114 | "slide_type": "subslide" 115 | } 116 | }, 117 | "source": [ 118 | "### ¿Por qué Julia?" 119 | ] 120 | }, 121 | { 122 | "cell_type": "markdown", 123 | "metadata": { 124 | "slideshow": { 125 | "slide_type": "fragment" 126 | } 127 | }, 128 | "source": [ 129 | "- Fácil de entender, alto nivel, interactivo -- como Python, MATLAB, R,..." 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "metadata": { 135 | "slideshow": { 136 | "slide_type": "fragment" 137 | } 138 | }, 139 | "source": [ 140 | "- **Pero** rendimiento (velocidad) comparable con C, C++ y Fortran\n" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": { 146 | "slideshow": { 147 | "slide_type": "fragment" 148 | } 149 | }, 150 | "source": [ 151 | "- Los desarrolladores querían *todo* en un solo lenguaje -- ¡y lo lograron!" 152 | ] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": { 157 | "slideshow": { 158 | "slide_type": "subslide" 159 | } 160 | }, 161 | "source": [ 162 | "### Desarrollo de Julia" 163 | ] 164 | }, 165 | { 166 | "cell_type": "markdown", 167 | "metadata": { 168 | "slideshow": { 169 | "slide_type": "fragment" 170 | } 171 | }, 172 | "source": [ 173 | "- Software libre; licencia MIT\n", 174 | "\n", 175 | "\n", 176 | "- Disponible en todas las plataformas" 177 | ] 178 | }, 179 | { 180 | "cell_type": "markdown", 181 | "metadata": { 182 | "slideshow": { 183 | "slide_type": "subslide" 184 | } 185 | }, 186 | "source": [ 187 | "- Comunidad de desarrolladores repartido en todo el mundo\n", 188 | "\n", 189 | "\n", 190 | "- Se desarrolla en línea de forma abierta en https://github.com/JuliaLang/julia\n", 191 | "\n", 192 | "\n", 193 | "- Más de 2000 paquetes / bibliotecas registrados" 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": { 199 | "slideshow": { 200 | "slide_type": "slide" 201 | } 202 | }, 203 | "source": [ 204 | "### Ciencia abierta" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": { 210 | "slideshow": { 211 | "slide_type": "fragment" 212 | } 213 | }, 214 | "source": [ 215 | "- Por su naturaleza, la ciencia exige que cualquier código científico debe ser disponible de forma libre y reproducible\n", 216 | "\n", 217 | "\n", 218 | "- Por lo tanto, es necesario utilizar **software libre**\n", 219 | "\n", 220 | "\n", 221 | "- Con una licencia poco restrictiva\n" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": { 227 | "slideshow": { 228 | "slide_type": "subslide" 229 | } 230 | }, 231 | "source": [ 232 | "### Julia es estable\n", 233 | "\n", 234 | "- Hoy: versión v1.0.3\n", 235 | "\n", 236 | "- Mañana: versión 1.1" 237 | ] 238 | }, 239 | { 240 | "cell_type": "markdown", 241 | "metadata": { 242 | "slideshow": { 243 | "slide_type": "slide" 244 | } 245 | }, 246 | "source": [ 247 | "## Cómo utilizar Julia" 248 | ] 249 | }, 250 | { 251 | "cell_type": "markdown", 252 | "metadata": {}, 253 | "source": [ 254 | "#### En línea, sin instalar nada\n", 255 | "\n", 256 | "- http://www.juliabox.com\n", 257 | "\n", 258 | "\n", 259 | "#### De forma local en tu propia computadora\n", 260 | "\n", 261 | "- Bajar desde http://www.julialang.org/downloads" 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": { 267 | "slideshow": { 268 | "slide_type": "fragment" 269 | } 270 | }, 271 | "source": [ 272 | "### Entornos para utilizar Julia\n", 273 | "\n", 274 | "\n", 275 | "- **Jupyter** notebook: cuaderno interactivo a través del navegador web\n", 276 | "\n", 277 | " - en tu propia computadora (instrucciones abajo)\n", 278 | "\n", 279 | " - en línea: [juliabox.com](http://juliabox.com)\n", 280 | " \n", 281 | " - en el IPad con [Juno app](https://juno.sh/)\n", 282 | " \n", 283 | "- Nueva versión: **JupyterLab**" 284 | ] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": { 289 | "slideshow": { 290 | "slide_type": "fragment" 291 | } 292 | }, 293 | "source": [ 294 | "- **REPL** (línea de comandos): Flujo de trabajo interactivo" 295 | ] 296 | }, 297 | { 298 | "cell_type": "markdown", 299 | "metadata": { 300 | "slideshow": { 301 | "slide_type": "fragment" 302 | } 303 | }, 304 | "source": [ 305 | "- [Juno](http://junolab.org/): IDE (entorno de desarrollo integrado) para Julia, dentro del editor Atom; evaluación \"inline\"\n", 306 | "\n", 307 | "- [Nteract](https://nteract.io), una aplicación de escritorio para manipular notebooks " 308 | ] 309 | }, 310 | { 311 | "cell_type": "markdown", 312 | "metadata": { 313 | "slideshow": { 314 | "slide_type": "subslide" 315 | } 316 | }, 317 | "source": [ 318 | "## Instalación del Jupyter notebook:\n", 319 | "\n", 320 | "- Abre Julia e instala el paquete `IJulia`, e.g. desde el REPL:\n", 321 | "\n", 322 | " - Teclear `]`, lo cual cambia el modo a `(v1.0) pkg>` \n", 323 | " \n", 324 | " - `add IJulia`\n", 325 | " \n", 326 | "- Ahora carga el notebook:\n", 327 | "\n", 328 | " - `julia> using IJulia`\n", 329 | " \n", 330 | " - `julia> notebook()`\n", 331 | " \n", 332 | "\n", 333 | "- Para saber en cuál directorio estás trabajando, utiliza `julia> pwd()`\n", 334 | "\n" 335 | ] 336 | }, 337 | { 338 | "cell_type": "markdown", 339 | "metadata": {}, 340 | "source": [ 341 | "## Recursos para aprender Julia" 342 | ] 343 | }, 344 | { 345 | "cell_type": "markdown", 346 | "metadata": {}, 347 | "source": [ 348 | "- \"Cheatsheets\" - resúmenes de la sintaxis:\n", 349 | "\n", 350 | " - [A Fast Track to Julia: A Quick and Dirty Overview (Cheatsheet)](https://juliadocs.github.io/Julia-Cheat-Sheet/) \n", 351 | " - [A Julia cheat sheet](https://github.com/stevengj/1806/blob/master/julia/Julia-cheatsheet.pdf) por Steven Johnson \n", 352 | " \n", 353 | " \n", 354 | "- Video introductorio a Julia 1.0: (inglés)\n", 355 | "\n", 356 | " - [Intro to Julia](https://www.youtube.com/watch?v=8h8rQyEpiZA&t) por Jane Herriman \n", 357 | " \n", 358 | " \n", 359 | "- Versión en espanõl con algunas cosas de sintaxis que ya han cambiado:\n", 360 | "\n", 361 | " - [Introducción a Julia en español](https://youtu.be/LbTbs-0pOuc) por Miguel Raz Guzmán\n", 362 | " \n", 363 | " \n", 364 | "- Libros sobre Julia\n", 365 | "\n", 366 | " - ThinkJulia\n", 367 | " \n", 368 | " - Álgebra lineal con Julia" 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "metadata": { 374 | "slideshow": { 375 | "slide_type": "subslide" 376 | } 377 | }, 378 | "source": [ 379 | "## Cómo obtenir ayuda\n" 380 | ] 381 | }, 382 | { 383 | "cell_type": "markdown", 384 | "metadata": { 385 | "slideshow": { 386 | "slide_type": "fragment" 387 | } 388 | }, 389 | "source": [ 390 | "- Interactivamente (REPL / Juno / IJulia): `?sin`" 391 | ] 392 | }, 393 | { 394 | "cell_type": "markdown", 395 | "metadata": { 396 | "slideshow": { 397 | "slide_type": "fragment" 398 | } 399 | }, 400 | "source": [ 401 | "- Manual de referencia: https://docs.julialang.org/en/stable\n", 402 | "\n", 403 | "\n", 404 | "- Foro de discusión: https://discourse.julialang.org/\n", 405 | "\n", 406 | "\n", 407 | "- Slack (mensajes instantáneos): http://slackinvite.julialang.org\n", 408 | "\n", 409 | "\n", 410 | "- Recursos para aprender: http://julialang.org/learning\n", 411 | "\n", 412 | "\n", 413 | "- Paquetes etc.: https://juliaobserver.com/" 414 | ] 415 | }, 416 | { 417 | "cell_type": "markdown", 418 | "metadata": {}, 419 | "source": [] 420 | } 421 | ], 422 | "metadata": { 423 | "kernelspec": { 424 | "display_name": "Julia 1.0.0", 425 | "language": "julia", 426 | "name": "julia-1.0" 427 | }, 428 | "language_info": { 429 | "file_extension": ".jl", 430 | "mimetype": "application/julia", 431 | "name": "julia", 432 | "version": "1.0.2" 433 | }, 434 | "toc": { 435 | "colors": { 436 | "hover_highlight": "#DAA520", 437 | "running_highlight": "#FF0000", 438 | "selected_highlight": "#FFD700" 439 | }, 440 | "moveMenuLeft": true, 441 | "nav_menu": { 442 | "height": "139px", 443 | "width": "252px" 444 | }, 445 | "navigate_menu": true, 446 | "number_sections": true, 447 | "sideBar": true, 448 | "threshold": "2", 449 | "toc_cell": false, 450 | "toc_section_display": "block", 451 | "toc_window_display": false 452 | } 453 | }, 454 | "nbformat": 4, 455 | "nbformat_minor": 2 456 | } 457 | -------------------------------------------------------------------------------- /notebooks/05. Estadistica de caminatas aleatorias.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Análisis estadístico de caminatas aleatorias" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Una tarea fundamental en la física es el análisis de datos. \n", 15 | "A menudo, un experimento produce una cierta cantidad de datos correspondientes a la medición de ciertas cantidades. Se repite una medición varias veces para asegurar que sea reproducible, y luego se llevan a cabo análisis de estos datos.\n", 16 | "\n", 17 | "Podemos llevar a cabo el mismo proceso con los datos provenientes de un **experimento numérico**, o sea, una simulación.\n", 18 | "\n", 19 | "Retomemos nuestra simulación de caminatas aleatorias del notebook anterior y recordemos algo de estadística para poder caracterizar a las caminatas (y para finalmente entender la estadística...)." 20 | ] 21 | }, 22 | { 23 | "cell_type": "markdown", 24 | "metadata": {}, 25 | "source": [ 26 | "## Datos" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "Pensemos en una caminata aleatoria como el experimento. Al repetir varias veces la caminata, saldrán datos diferentes. ¿Cómo podemos caracterizar estos datos?" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "#### Ejercicio 1" 41 | ] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "(i) Escribe una función `caminatas` para simular la dinámica de $N$ caminatas aleatorias para un tiempo total $T$. Sigue los pasos siguientes.\n", 48 | "\n", 49 | "1. Crea un vector llamado `xs` de enteros ceros de longitud $N$ con la función `zeros`. [Pista: Utiliza `?zeros` para ver la documentación de la función.]\n", 50 | "\n", 51 | "\n", 52 | "2. Haz una función `paso!` que acepte como argumentos `xs` e `i` y lleva a cabo un paso del caminante número $i$. [Puedes acceder a la entrada número `i` del vector `xs` con `xs[i]`.]\n", 53 | "\n", 54 | "\n", 55 | "3. Haz una función `paso!` (mismo nombre) que acepte sólo el argumento `xs` y lleva a cabo un paso de todos los caminantes.\n", 56 | "[Pista: La función `length` nos dice cuántos elementos contiene un `Vector`.]\n", 57 | "\n", 58 | "\n", 59 | "4. Haz la función `caminatas`. Guarda el vector de `xs` en cada paso en un vector nuevo `posiciones`. Tendrás que utilizar la función `copy` para copiar `xs`. (¿Qué ocurre si no lo haces?)\n", 60 | "La función regresa todos los datos." 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": null, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "metadata": {}, 73 | "source": [ 74 | "(ii) Simula 1000 caminantes para un tiempo 100 y capta la salida de la función en una variable `posiciones`." 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": null, 80 | "metadata": {}, 81 | "outputs": [], 82 | "source": [] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "## Promedios" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "La primera cosa que se nos debe ocurrir es sacar el **promedio** de los datos. Podemos pensar en calcular el promedio en cada tiempo." 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "#### Ejercicio 2" 103 | ] 104 | }, 105 | { 106 | "cell_type": "markdown", 107 | "metadata": {}, 108 | "source": [ 109 | "(i) Si simulas $N$ caminatas aleatorias $x_i(t)$, con $i=1, \\ldots, N$, para un tiempo total (número de pasos) $T$, ¿cómo esperas salga el promedio de todos los $x_i(t)$ con un tiempo $t$ fijo?" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "(ii) Escribe una función `promedio` que calcule el promedio de un vector. Acepta el vector `v` como argumento y regresa el promedio." 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "(iii) Escribe una función `promedios` que calcula los promedios de $x_i(t)$ para cada $t$. " 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "(iv) Calcula los promedios de 1000 caminantes por un tiempo 100. " 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": null, 157 | "metadata": {}, 158 | "outputs": [], 159 | "source": [] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "metadata": {}, 164 | "source": [ 165 | "(v) Dibuja el promedio como función del tiempo. ¿Es lo que esperabas?" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "## Estadística " 173 | ] 174 | }, 175 | { 176 | "cell_type": "markdown", 177 | "metadata": {}, 178 | "source": [ 179 | "Ya hemos recordado la primera cantidad estadística fundamental, el promedio, y vimos que no nos dio información tan valiosa. ¿Cuál es la siguiente cantidad importante?" 180 | ] 181 | }, 182 | { 183 | "cell_type": "markdown", 184 | "metadata": {}, 185 | "source": [ 186 | "#### Ejercicio 3\n", 187 | "\n", 188 | "(i) Escribe una función `varianza` que calcule la varianza de un vector `v`." 189 | ] 190 | }, 191 | { 192 | "cell_type": "code", 193 | "execution_count": null, 194 | "metadata": {}, 195 | "outputs": [], 196 | "source": [] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "(ii) Escribe una función que calcule las varianzas de las $x_i(t)$ para una $t$ dada." 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": null, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "(iii) Dibuja la varianza como función del tiempo. Repite el cálculo varias veces y dibuja las distintas curvas en una sola gráfica. ¿Qué observas? ¿Cómo crece la varianza?" 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": null, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "metadata": {}, 229 | "source": [ 230 | "(iv) Haz lo mismo para la desviación estándar." 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": null, 236 | "metadata": {}, 237 | "outputs": [], 238 | "source": [] 239 | }, 240 | { 241 | "cell_type": "markdown", 242 | "metadata": {}, 243 | "source": [ 244 | "### Densidad de probabilidad" 245 | ] 246 | }, 247 | { 248 | "cell_type": "markdown", 249 | "metadata": {}, 250 | "source": [ 251 | "El promedio y la varianza son medidas burdas que caracterizan a una colección de datos. Una medida más refinada es la **distribución de probabilidad**. Una forma de caracterizarla es a través de un **histograma**, que nos proporciona la **densidad de probabilidad** o densidad de masa." 252 | ] 253 | }, 254 | { 255 | "cell_type": "markdown", 256 | "metadata": {}, 257 | "source": [ 258 | "#### Ejercicio 4" 259 | ] 260 | }, 261 | { 262 | "cell_type": "markdown", 263 | "metadata": {}, 264 | "source": [ 265 | "(i) ¿Qué es lo que mide un histograma?" 266 | ] 267 | }, 268 | { 269 | "cell_type": "code", 270 | "execution_count": null, 271 | "metadata": {}, 272 | "outputs": [], 273 | "source": [] 274 | }, 275 | { 276 | "cell_type": "markdown", 277 | "metadata": {}, 278 | "source": [ 279 | "(ii) `Plots.jl` contiene una función `histograma`. Busca documentación y/o ejemplos del uso de esta función para dibujar, en una sola gráfica, algunos histogramas normalizados correspondientes a algunos tiempos $t$." 280 | ] 281 | }, 282 | { 283 | "cell_type": "code", 284 | "execution_count": null, 285 | "metadata": {}, 286 | "outputs": [], 287 | "source": [] 288 | }, 289 | { 290 | "cell_type": "markdown", 291 | "metadata": {}, 292 | "source": [ 293 | "## Caminatas con sesgo" 294 | ] 295 | }, 296 | { 297 | "cell_type": "markdown", 298 | "metadata": {}, 299 | "source": [ 300 | "Las caminatas hasta ahora han brincado con la misma probabilidad a la izquierda y a la derecha. Ahora vamos a relajar esta restricción." 301 | ] 302 | }, 303 | { 304 | "cell_type": "markdown", 305 | "metadata": {}, 306 | "source": [ 307 | "#### Ejercicio 5\n", 308 | "\n", 309 | "(i) Simula $N = 1000$ números aleatorios entre $0$ y $1$ con la función `rand`." 310 | ] 311 | }, 312 | { 313 | "cell_type": "code", 314 | "execution_count": null, 315 | "metadata": {}, 316 | "outputs": [], 317 | "source": [] 318 | }, 319 | { 320 | "cell_type": "markdown", 321 | "metadata": {}, 322 | "source": [ 323 | "(ii) Calcula la fracción de los números que salgan menores que 0.1, menores que 0.2, menores que 0.3, etc, es decir, la **probabilidad** de que salgan menores que 0.1 etc. ¿Qué observas?" 324 | ] 325 | }, 326 | { 327 | "cell_type": "code", 328 | "execution_count": null, 329 | "metadata": {}, 330 | "outputs": [], 331 | "source": [] 332 | }, 333 | { 334 | "cell_type": "markdown", 335 | "metadata": {}, 336 | "source": [ 337 | "(iii) Así, escribe una función `mi_rand` que acepte un valor $0 \\le p \\le 1$ y genere `true` con probabilidad $p$, y `false` con probabilidad $1-p$. Para hacerlo, podrás hacer uso de un condicional." 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": null, 343 | "metadata": {}, 344 | "outputs": [], 345 | "source": [] 346 | }, 347 | { 348 | "cell_type": "markdown", 349 | "metadata": {}, 350 | "source": [ 351 | "#### Ejercicio 6" 352 | ] 353 | }, 354 | { 355 | "cell_type": "markdown", 356 | "metadata": {}, 357 | "source": [ 358 | "(i) Dibuja una nube de trayectorias para distintos valores de $p$. Cada nube debe ir en una sola gráfica; las nubes con distintos valores de $p$ van en gráficas por separado.\n", 359 | "\n", 360 | "Para hacerlo, haz un bucle sobre valores de $p$.\n", 361 | "\n", 362 | "¿Qué observas?" 363 | ] 364 | }, 365 | { 366 | "cell_type": "code", 367 | "execution_count": null, 368 | "metadata": {}, 369 | "outputs": [], 370 | "source": [] 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "(ii) Repite las preguntas 2, 3 y 4 para caminantes que brincan con probabilidad $p$ a la izquierda y $q = 1-p$ a la derecha. ¿Qué observas?" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": null, 382 | "metadata": {}, 383 | "outputs": [], 384 | "source": [] 385 | } 386 | ], 387 | "metadata": { 388 | "kernelspec": { 389 | "display_name": "Julia 1.0.3", 390 | "language": "julia", 391 | "name": "julia-1.0" 392 | }, 393 | "language_info": { 394 | "file_extension": ".jl", 395 | "mimetype": "application/julia", 396 | "name": "julia", 397 | "version": "1.0.3" 398 | } 399 | }, 400 | "nbformat": 4, 401 | "nbformat_minor": 2 402 | } 403 | -------------------------------------------------------------------------------- /notebooks/22. Valores y vectores propios.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Eigenvalores y eigenvectores " 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Otro problema crucial de la álgebra lineal, y, por lo tanto, de la álgebra lineal numérica, es encontrar valores y vectores propios, también llamados eigenvalores y eigenvectores (\"eigen\" = \"propio\" en alemán).\n", 15 | "\n", 16 | "Recordemos que $\\mathbf{v}$ es un eigenvector de la matriz $\\mathsf{M}$, con eigenvalor $\\lambda \\in \\mathbb{C}$, si\n", 17 | "\n", 18 | "$$\\mathsf{M} \\cdot \\mathbf{v} = \\lambda \\, \\mathbf{v},$$\n", 19 | "\n", 20 | "es decir que la *dirección* de $\\mathbf{v}$ es invariante bajo la transformación $\\mathsf{M}$, pero la *magnitud* se puede cambiar (o sea, el vector se puede \"estirar\").\n", 21 | "\n", 22 | "Recordemos que si $\\mathbf{v}$ es un eigenvector de $\\mathsf{M}$ con eigenvalor $\\lambda$, entonces $\\alpha \\mathbf{v}$ también lo es, para cualquier escalar $\\alpha \\neq 0$." 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "¿Por qué son importantes este tipo de problemas? Surgen en problemas físicos como son el encontrar los modos normales de un conjunto de osciladores acoplados, o las energías posibles de un sistema cuántico. En particular, surgen al llevar a cabo una separación de variables en ecuaciones diferenciales parciales.\n", 30 | "\n", 31 | "Por ejemplo, consideremos el problema de encontrar las energías y estados posibles de una partícula libre en una caja finita de longitud $L$. El problema se reduce a encontrar los valores posibles de $E$ y $\\psi$ que satisfacen la ecuación de Helmholtz,\n", 32 | "\n", 33 | "$$\\nabla^2 \\psi = E \\psi$$\n", 34 | "\n", 35 | "con condiciones dadas en la frontera, por ejemplo\n", 36 | "$\\psi(x=0) = \\psi(x=L) = 0$." 37 | ] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "## El método de potencias " 44 | ] 45 | }, 46 | { 47 | "cell_type": "markdown", 48 | "metadata": {}, 49 | "source": [ 50 | "No pueden existir métodos directos para calcular eigenvalores para matrices generales, ya que los eigenvalores satisfacen la ecuación polinomial $\\mathrm{det}(\\mathsf{M} - \\lambda \\mathsf{I}) = 0$, la cual sabemos que no se puede resolver de manera exacta cuando el grado $>4$.\n", 51 | "\n", 52 | "Por lo tanto, debemos considerar métodos iterativos." 53 | ] 54 | }, 55 | { 56 | "cell_type": "markdown", 57 | "metadata": {}, 58 | "source": [ 59 | "El método iterativo más sencillo para calcular un eigenvalor particular de una matriz es el **método de potencias**. Consiste en calcular potencias de la matriz $\\mathsf{M}$, aplicadas a un vector $\\mathbf{v}$ inicial arbitrario (pero no-cero).\n", 60 | "\n", 61 | "El algoritmo es como sigue: Se escoge un vector inicial arbitrario y se aplica $\\mathsf{M}$ a este vector (es decir, se calcula $\\mathsf{M} \\cdot \\mathbf{v}$). Luego se aplica $\\mathsf{M}$ al resultado, y así sucesivamente.\n" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "#### Ejercicio 1\n", 69 | "\n", 70 | "(i) Escribe una función que implementa este método, para una matriz `M` dada." 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "metadata": {}, 77 | "outputs": [], 78 | "source": [] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "(ii) Considera una matriz $\\mathbf{M}$ de $2 \\times 2$, e.g. $\\begin{pmatrix} 2 & 1 \\\\ 1 & 1 \\end{pmatrix}$. \n", 85 | "Aplica el método. Imprime los resultados después de cada paso. ¿Cuál " 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "problema observas?\n", 100 | "\n", 101 | "(iii) ¿Cuál es la solución a este problema? Impleméntalo. " 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": null, 107 | "metadata": {}, 108 | "outputs": [], 109 | "source": [] 110 | }, 111 | { 112 | "cell_type": "markdown", 113 | "metadata": {}, 114 | "source": [ 115 | "(iv) Calcula a mano los eigenvalores y eigenvectores de tu matriz. ¿Funciona el método? ¿Cuál eigenvector y eigenvalor te da?" 116 | ] 117 | }, 118 | { 119 | "cell_type": "code", 120 | "execution_count": null, 121 | "metadata": {}, 122 | "outputs": [], 123 | "source": [] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "(v) Supón que la matriz $\\mathsf{M}$ cuenta con una base completa de eigenvectores $\\mathbf{v}_i$. Descompone un vector inicial arbitrario $\\mathbf{v}$ como una combinación lineal de los eigenvectores, e investiga el resultado de aplicar $\\mathsf{M}^n$ a este vector inicial. Así, explica (con papel y pluma) el comportamiento del método." 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": null, 135 | "metadata": {}, 136 | "outputs": [], 137 | "source": [] 138 | }, 139 | { 140 | "cell_type": "markdown", 141 | "metadata": {}, 142 | "source": [ 143 | "#### Ejercicio 2\n", 144 | "Aplica el método a la matriz de discretización de la partícula libre en una caja. ¿Cuál eigenvalor está calculando? ¿Qué ocurre?" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": null, 150 | "metadata": {}, 151 | "outputs": [], 152 | "source": [] 153 | }, 154 | { 155 | "cell_type": "markdown", 156 | "metadata": {}, 157 | "source": [ 158 | "#### Ejercicio 3 (Opcional) \n", 159 | "\n", 160 | "Considera una matriz real y **simétrica**, $\\mathsf{S}$. Extiende el método de potencias para calcular *varios* eigenvalores y eigenvectores. [Pista: ¿cuáles propiedades especiales tienen las matrices simétricas, en términos de eigenvalores y eigenvectores?] " 161 | ] 162 | }, 163 | { 164 | "cell_type": "code", 165 | "execution_count": null, 166 | "metadata": {}, 167 | "outputs": [], 168 | "source": [] 169 | }, 170 | { 171 | "cell_type": "markdown", 172 | "metadata": {}, 173 | "source": [ 174 | "## Facilidades de Julia para álgebra lineal numérica " 175 | ] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "Resulta que Julia cuenta con facilidades muy completas para llevar a cabo tareas de álgebra lineal numérica. \n", 182 | "Provee un interfaz fácil de utilizar a librerías estándares como LAPACK.\n", 183 | "Para nuestros fines, dos de los más importantes son los siguientes.\n", 184 | "\n", 185 | "### Sistemas de ecuaciones lineales\n", 186 | "\n", 187 | "Para resolver el sistema de ecuaciones lineales $\\mathsf{A} \\cdot \\mathbf{x} = \\mathbf{b}$, utilizamos\n", 188 | "\n", 189 | " A \\ b\n", 190 | " \n", 191 | "[La notación rara surge así: `b / A` se puede considerar como $b \\, A^{-1}$. De la misma forma, `A \\ b` denote $A^{-1} \\, b$. Nótese que numéricamente **nunca** hay que calcular explícitamente la inversa de una matriz, sino más bien resolvemos directamente un sistema de ecuaciones].\n", 192 | "\n", 193 | "¿Qué algoritmo utiliza? Resulta que es inteligente: intenta escoger el algoritmo más adecuado para un problema dado." 194 | ] 195 | }, 196 | { 197 | "cell_type": "markdown", 198 | "metadata": {}, 199 | "source": [ 200 | "### Problemas de eigenvalores y eigenvectores\n", 201 | "\n", 202 | "El cálculo de eigenvalores y eigenvectores en general es un área complicada. Julia provee, de nuevo, un interfaz sencillo a algoritmos ya probados. La sintaxis es\n", 203 | "\n", 204 | " eig(A)\n", 205 | " eigvals(A)\n", 206 | " eigvecs(A)" 207 | ] 208 | }, 209 | { 210 | "cell_type": "markdown", 211 | "metadata": {}, 212 | "source": [ 213 | "#### Ejercicio 4\n", 214 | "Calcula los eigenvalores y eigenvectores de la matriz de discretización del operador de Schrödinger para una partícula libre. Compáralos con los resultados analíticos. ¿Qué observas?" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "#### Ejercicio 5\n", 229 | "Haz lo mismo para el oscilador armónico cuántico." 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": {}, 236 | "outputs": [], 237 | "source": [] 238 | }, 239 | { 240 | "cell_type": "markdown", 241 | "metadata": {}, 242 | "source": [ 243 | "## Modos normales" 244 | ] 245 | }, 246 | { 247 | "cell_type": "markdown", 248 | "metadata": {}, 249 | "source": [ 250 | "#### Ejercicio 6\n", 251 | "\n", 252 | "Considera un sistema compuesto por cuatro carritos de masa $m$, acoplados con resortes sobre una pista recta. El carrito en cada extremo está acoplado mediante un resorte a una pared. Todos los resortes obedecen la ley de Hooke con la misma constante $k$.\n", 253 | "\n", 254 | "\n", 255 | "(i) Deduce las ecuaciones de movimiento a partir de la segunda ley de Newton y escríbelas en forma matricial. " 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": null, 261 | "metadata": {}, 262 | "outputs": [], 263 | "source": [] 264 | }, 265 | { 266 | "cell_type": "markdown", 267 | "metadata": {}, 268 | "source": [ 269 | "(ii) Para resolver el sistema de ecuaciones, proponemos la solución\n", 270 | "\n", 271 | "$$\n", 272 | "\\vec{x}(t) = \\mathrm{Re}(\\vec{z}(t)), \\quad \\vec{z}(t) = \\vec{a}e^{i\\omega t},\n", 273 | "$$\n", 274 | "donde $\\vec{a}$ es un vector complejo que tiene la información de la amplitud y la fase de las oscilaciones, que dependen de las condiciones iniciales. \n", 275 | "\n", 276 | "Las **frecuencias normales** del sistema son las raíces positivas de la ecuación característica de la matriz $\\mathbb{K} - \\omega^2\\mathbb{M}$ y los modos normales son los vectores que satisfacen la ecuación de autovalores $(\\mathbb{K} - \\omega^2\\mathbb{M})\\vec{a} = 0$. El movimiento del sistema está dado por la superposición de todos los modos normales." 277 | ] 278 | }, 279 | { 280 | "cell_type": "code", 281 | "execution_count": null, 282 | "metadata": {}, 283 | "outputs": [], 284 | "source": [] 285 | }, 286 | { 287 | "cell_type": "markdown", 288 | "metadata": {}, 289 | "source": [ 290 | "(iii) Calcula las frecuencias normales y los modos normales del sistema." 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": null, 296 | "metadata": {}, 297 | "outputs": [], 298 | "source": [] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "(iv) Grafica, para cada modo normal, la posición de los carritos como función del tiempo. Describe cada modo normal en términos del movimiento de cada carrito." 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": null, 310 | "metadata": {}, 311 | "outputs": [], 312 | "source": [] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "(v) Haz una animación del movimiento." 319 | ] 320 | }, 321 | { 322 | "cell_type": "code", 323 | "execution_count": null, 324 | "metadata": {}, 325 | "outputs": [], 326 | "source": [] 327 | } 328 | ], 329 | "metadata": { 330 | "kernelspec": { 331 | "display_name": "Julia 1.0.3", 332 | "language": "julia", 333 | "name": "julia-1.0" 334 | }, 335 | "language_info": { 336 | "file_extension": ".jl", 337 | "mimetype": "application/julia", 338 | "name": "julia", 339 | "version": "1.0.3" 340 | } 341 | }, 342 | "nbformat": 4, 343 | "nbformat_minor": 1 344 | } 345 | -------------------------------------------------------------------------------- /notebooks/Metaprogramacion basica.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "ename": "UndefVarError", 10 | "evalue": "UndefVarError: x not defined", 11 | "output_type": "error", 12 | "traceback": [ 13 | "UndefVarError: x not defined", 14 | "", 15 | "Stacktrace:", 16 | " [1] top-level scope at In[1]:1" 17 | ] 18 | } 19 | ], 20 | "source": [ 21 | "y = x + 2" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 2, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "data": { 31 | "text/plain": [ 32 | "\"y = x + 2\"" 33 | ] 34 | }, 35 | "execution_count": 2, 36 | "metadata": {}, 37 | "output_type": "execute_result" 38 | } 39 | ], 40 | "source": [ 41 | "s = \"y = x + 2\"" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 3, 47 | "metadata": {}, 48 | "outputs": [ 49 | { 50 | "data": { 51 | "text/plain": [ 52 | ":(y = x + 2)" 53 | ] 54 | }, 55 | "execution_count": 3, 56 | "metadata": {}, 57 | "output_type": "execute_result" 58 | } 59 | ], 60 | "source": [ 61 | "ex = Meta.parse(s)" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 4, 67 | "metadata": {}, 68 | "outputs": [ 69 | { 70 | "data": { 71 | "text/plain": [ 72 | "Expr" 73 | ] 74 | }, 75 | "execution_count": 4, 76 | "metadata": {}, 77 | "output_type": "execute_result" 78 | } 79 | ], 80 | "source": [ 81 | "typeof(ans)" 82 | ] 83 | }, 84 | { 85 | "cell_type": "code", 86 | "execution_count": 5, 87 | "metadata": {}, 88 | "outputs": [ 89 | { 90 | "data": { 91 | "text/plain": [ 92 | ":($(Expr(:incomplete, \"incomplete: premature end of input\")))" 93 | ] 94 | }, 95 | "execution_count": 5, 96 | "metadata": {}, 97 | "output_type": "execute_result" 98 | } 99 | ], 100 | "source": [ 101 | "Meta.parse(\"y = x + \")" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 6, 107 | "metadata": {}, 108 | "outputs": [ 109 | { 110 | "data": { 111 | "text/plain": [ 112 | ":(y = x + 2)" 113 | ] 114 | }, 115 | "execution_count": 6, 116 | "metadata": {}, 117 | "output_type": "execute_result" 118 | } 119 | ], 120 | "source": [ 121 | "ex" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 7, 127 | "metadata": {}, 128 | "outputs": [ 129 | { 130 | "name": "stdout", 131 | "output_type": "stream", 132 | "text": [ 133 | "Expr\n", 134 | " head: Symbol =\n", 135 | " args: Array{Any}((2,))\n", 136 | " 1: Symbol y\n", 137 | " 2: Expr\n", 138 | " head: Symbol call\n", 139 | " args: Array{Any}((3,))\n", 140 | " 1: Symbol +\n", 141 | " 2: Symbol x\n", 142 | " 3: Int64 2\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "dump(ex)" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 8, 153 | "metadata": {}, 154 | "outputs": [ 155 | { 156 | "data": { 157 | "text/plain": [ 158 | "2-element Array{Any,1}:\n", 159 | " :y \n", 160 | " :(x + 2)" 161 | ] 162 | }, 163 | "execution_count": 8, 164 | "metadata": {}, 165 | "output_type": "execute_result" 166 | } 167 | ], 168 | "source": [ 169 | "ex.args" 170 | ] 171 | }, 172 | { 173 | "cell_type": "code", 174 | "execution_count": 9, 175 | "metadata": {}, 176 | "outputs": [ 177 | { 178 | "data": { 179 | "text/plain": [ 180 | ":y" 181 | ] 182 | }, 183 | "execution_count": 9, 184 | "metadata": {}, 185 | "output_type": "execute_result" 186 | } 187 | ], 188 | "source": [ 189 | "ex.args[1]" 190 | ] 191 | }, 192 | { 193 | "cell_type": "code", 194 | "execution_count": 10, 195 | "metadata": {}, 196 | "outputs": [ 197 | { 198 | "data": { 199 | "text/plain": [ 200 | ":z" 201 | ] 202 | }, 203 | "execution_count": 10, 204 | "metadata": {}, 205 | "output_type": "execute_result" 206 | } 207 | ], 208 | "source": [ 209 | "ex.args[1] = :z" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 11, 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "data": { 219 | "text/plain": [ 220 | ":(z = x + 2)" 221 | ] 222 | }, 223 | "execution_count": 11, 224 | "metadata": {}, 225 | "output_type": "execute_result" 226 | } 227 | ], 228 | "source": [ 229 | "ex" 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": 13, 235 | "metadata": {}, 236 | "outputs": [ 237 | { 238 | "data": { 239 | "text/plain": [ 240 | ":(x + 2)" 241 | ] 242 | }, 243 | "execution_count": 13, 244 | "metadata": {}, 245 | "output_type": "execute_result" 246 | } 247 | ], 248 | "source": [ 249 | "ex.args[2]" 250 | ] 251 | }, 252 | { 253 | "cell_type": "code", 254 | "execution_count": 14, 255 | "metadata": {}, 256 | "outputs": [ 257 | { 258 | "data": { 259 | "text/plain": [ 260 | "3-element Array{Any,1}:\n", 261 | " :+\n", 262 | " :x\n", 263 | " 2 " 264 | ] 265 | }, 266 | "execution_count": 14, 267 | "metadata": {}, 268 | "output_type": "execute_result" 269 | } 270 | ], 271 | "source": [ 272 | "ex.args[2].args" 273 | ] 274 | }, 275 | { 276 | "cell_type": "code", 277 | "execution_count": 15, 278 | "metadata": {}, 279 | "outputs": [ 280 | { 281 | "data": { 282 | "text/plain": [ 283 | ":x" 284 | ] 285 | }, 286 | "execution_count": 15, 287 | "metadata": {}, 288 | "output_type": "execute_result" 289 | } 290 | ], 291 | "source": [ 292 | "ex.args[2].args[2]" 293 | ] 294 | }, 295 | { 296 | "cell_type": "code", 297 | "execution_count": 18, 298 | "metadata": {}, 299 | "outputs": [ 300 | { 301 | "data": { 302 | "text/plain": [ 303 | ":(x * x)" 304 | ] 305 | }, 306 | "execution_count": 18, 307 | "metadata": {}, 308 | "output_type": "execute_result" 309 | } 310 | ], 311 | "source": [ 312 | "ex.args[2].args[2] = :(x * x)" 313 | ] 314 | }, 315 | { 316 | "cell_type": "code", 317 | "execution_count": 19, 318 | "metadata": {}, 319 | "outputs": [ 320 | { 321 | "data": { 322 | "text/plain": [ 323 | ":(z = x * x + 2)" 324 | ] 325 | }, 326 | "execution_count": 19, 327 | "metadata": {}, 328 | "output_type": "execute_result" 329 | } 330 | ], 331 | "source": [ 332 | "ex" 333 | ] 334 | }, 335 | { 336 | "cell_type": "code", 337 | "execution_count": 20, 338 | "metadata": {}, 339 | "outputs": [ 340 | { 341 | "name": "stdout", 342 | "output_type": "stream", 343 | "text": [ 344 | " 0.123459 seconds (397.30 k allocations: 20.239 MiB, 4.36% gc time)\n" 345 | ] 346 | }, 347 | { 348 | "data": { 349 | "text/plain": [ 350 | "-0.5440211108893698" 351 | ] 352 | }, 353 | "execution_count": 20, 354 | "metadata": {}, 355 | "output_type": "execute_result" 356 | } 357 | ], 358 | "source": [ 359 | "@time sin(10)" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": 21, 365 | "metadata": {}, 366 | "outputs": [ 367 | { 368 | "data": { 369 | "text/plain": [ 370 | "quote\n", 371 | " #= util.jl:154 =#\n", 372 | " local #5#stats = (Base.gc_num)()\n", 373 | " #= util.jl:155 =#\n", 374 | " local #7#elapsedtime = (Base.time_ns)()\n", 375 | " #= util.jl:156 =#\n", 376 | " local #6#val = sin(10)\n", 377 | " #= util.jl:157 =#\n", 378 | " #7#elapsedtime = (Base.time_ns)() - #7#elapsedtime\n", 379 | " #= util.jl:158 =#\n", 380 | " local #8#diff = (Base.GC_Diff)((Base.gc_num)(), #5#stats)\n", 381 | " #= util.jl:159 =#\n", 382 | " (Base.time_print)(#7#elapsedtime, (#8#diff).allocd, (#8#diff).total_time, (Base.gc_alloc_count)(#8#diff))\n", 383 | " #= util.jl:161 =#\n", 384 | " (Base.println)()\n", 385 | " #= util.jl:162 =#\n", 386 | " #6#val\n", 387 | "end" 388 | ] 389 | }, 390 | "execution_count": 21, 391 | "metadata": {}, 392 | "output_type": "execute_result" 393 | } 394 | ], 395 | "source": [ 396 | "@macroexpand @time sin(10)" 397 | ] 398 | }, 399 | { 400 | "cell_type": "code", 401 | "execution_count": 22, 402 | "metadata": {}, 403 | "outputs": [ 404 | { 405 | "data": { 406 | "text/plain": [ 407 | ":(sin(10))" 408 | ] 409 | }, 410 | "execution_count": 22, 411 | "metadata": {}, 412 | "output_type": "execute_result" 413 | } 414 | ], 415 | "source": [ 416 | "ex = :(sin(10))" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": 23, 422 | "metadata": {}, 423 | "outputs": [ 424 | { 425 | "name": "stdout", 426 | "output_type": "stream", 427 | "text": [ 428 | "Expr\n", 429 | " head: Symbol call\n", 430 | " args: Array{Any}((2,))\n", 431 | " 1: Symbol sin\n", 432 | " 2: Int64 10\n" 433 | ] 434 | } 435 | ], 436 | "source": [ 437 | "dump(ex)" 438 | ] 439 | }, 440 | { 441 | "cell_type": "code", 442 | "execution_count": 25, 443 | "metadata": {}, 444 | "outputs": [ 445 | { 446 | "data": { 447 | "text/plain": [ 448 | "quote\n", 449 | " sin(10)\n", 450 | "end" 451 | ] 452 | }, 453 | "execution_count": 25, 454 | "metadata": {}, 455 | "output_type": "execute_result" 456 | } 457 | ], 458 | "source": [ 459 | "ex2 = Expr(:block, ex)" 460 | ] 461 | }, 462 | { 463 | "cell_type": "code", 464 | "execution_count": 26, 465 | "metadata": {}, 466 | "outputs": [ 467 | { 468 | "name": "stdout", 469 | "output_type": "stream", 470 | "text": [ 471 | "Expr\n", 472 | " head: Symbol block\n", 473 | " args: Array{Any}((1,))\n", 474 | " 1: Expr\n", 475 | " head: Symbol call\n", 476 | " args: Array{Any}((2,))\n", 477 | " 1: Symbol sin\n", 478 | " 2: Int64 10\n" 479 | ] 480 | } 481 | ], 482 | "source": [ 483 | "dump(ex2)" 484 | ] 485 | }, 486 | { 487 | "cell_type": "code", 488 | "execution_count": 29, 489 | "metadata": {}, 490 | "outputs": [ 491 | { 492 | "data": { 493 | "text/plain": [ 494 | "2-element Array{Any,1}:\n", 495 | " :(println(\"hola\"))\n", 496 | " :(sin(10)) " 497 | ] 498 | }, 499 | "execution_count": 29, 500 | "metadata": {}, 501 | "output_type": "execute_result" 502 | } 503 | ], 504 | "source": [ 505 | "pushfirst!(ex2.args, :(println(\"hola\")))" 506 | ] 507 | }, 508 | { 509 | "cell_type": "code", 510 | "execution_count": 30, 511 | "metadata": {}, 512 | "outputs": [ 513 | { 514 | "data": { 515 | "text/plain": [ 516 | "quote\n", 517 | " println(\"hola\")\n", 518 | " sin(10)\n", 519 | "end" 520 | ] 521 | }, 522 | "execution_count": 30, 523 | "metadata": {}, 524 | "output_type": "execute_result" 525 | } 526 | ], 527 | "source": [ 528 | "ex2" 529 | ] 530 | }, 531 | { 532 | "cell_type": "code", 533 | "execution_count": 31, 534 | "metadata": {}, 535 | "outputs": [ 536 | { 537 | "name": "stdout", 538 | "output_type": "stream", 539 | "text": [ 540 | "hola\n" 541 | ] 542 | }, 543 | { 544 | "data": { 545 | "text/plain": [ 546 | "-0.5440211108893698" 547 | ] 548 | }, 549 | "execution_count": 31, 550 | "metadata": {}, 551 | "output_type": "execute_result" 552 | } 553 | ], 554 | "source": [ 555 | "eval(ex2)" 556 | ] 557 | }, 558 | { 559 | "cell_type": "code", 560 | "execution_count": null, 561 | "metadata": {}, 562 | "outputs": [], 563 | "source": [] 564 | } 565 | ], 566 | "metadata": { 567 | "kernelspec": { 568 | "display_name": "Julia 1.0.3", 569 | "language": "julia", 570 | "name": "julia-1.0" 571 | }, 572 | "language_info": { 573 | "file_extension": ".jl", 574 | "mimetype": "application/julia", 575 | "name": "julia", 576 | "version": "1.0.3" 577 | } 578 | }, 579 | "nbformat": 4, 580 | "nbformat_minor": 2 581 | } 582 | -------------------------------------------------------------------------------- /notebooks/13. Ecuaciones diferenciales ordinarias - metodo de Euler.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Ecuaciones diferenciales ordinarias: el método de Euler" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Recordemos que una **ecuación diferencial ordinaria (EDO)** es (aproximadamente) una ecuación en la cual aparece una (o más) derivada(s) de una función, y para la cual queremos buscar la función que satisface esta relación.\n", 15 | "\n", 16 | "La EDO más simple no-trivial y físicamente relevante en una variable es \n", 17 | "\n", 18 | "$$\\dot{x} = -\\alpha \\, x. \\qquad (*)$$\n", 19 | "\n", 20 | "[Recordemos la notación $\\dot{x} := \\textstyle \\frac{dx}{dt}$, donde $t$ es el tiempo; es muy común en la física que las EDOs involucren derivadas con respecto al tiempo.]" 21 | ] 22 | }, 23 | { 24 | "cell_type": "markdown", 25 | "metadata": {}, 26 | "source": [ 27 | "Una solución a esta ecuación es un objeto $x$, tal que cuando la derivamos con respecto al tiempo, nos arroja $-\\alpha$ (una constante) multiplicada por el mismo objeto. Implícitamente está claro que $x$ depende de $t$, por lo que realmente $x$ se refiere a una función de $t$, es decir $x: \\mathbb{R} \\to \\mathbb{R}$ es la función $t \\mapsto x(t)$. \n", 28 | "\n", 29 | "Por lo tanto, la ecuación $\\dot{x} = -\\alpha x$ se puede considerar como una ecuación *funcional*, es decir, una igualdad entre funciones. \n", 30 | "\n", 31 | "Para entenderla, se reescribe de forma más explícita como sigue:\n", 32 | "\n", 33 | "$$\\dot{x}(t) = -\\alpha x(t) \\qquad \\text{para cada } t \\in \\mathbb{R}.$$\n", 34 | "\n", 35 | "Ahora es una igualdad de números, que dice que la \"velocidad\" en el tiempo $t$ es un cierto múltiplo de la posición en ese momento. De esta forma queda más claro (en mi opinión).\n", 36 | "\n", 37 | "Esto quiere decir que si *de alguna manera* hayamos logrado saber que la solución en el tiempo $t$ está en la posición $x(t)$, entonces nos indica cuál será la *velocidad* $\\dot{x}(t)$ en este momento. Esta es la información que necesitaremos para actualizar la solución al \"siguiente momento en el tiempo\" de forma numérica." 38 | ] 39 | }, 40 | { 41 | "cell_type": "markdown", 42 | "metadata": {}, 43 | "source": [ 44 | "La forma general de una EDO en una variable es\n", 45 | "\n", 46 | "$$\\dot{x} = f(x, t),$$\n", 47 | "\n", 48 | "o sea\n", 49 | "\n", 50 | "$$\\dot{x}(t) = f(x(t), t) \\qquad \\text{para cada } t \\in \\mathbb{R}.$$\n", 51 | "\n", 52 | "Recordemos que debe ir acompañada por una condición inicial $x(t=t_0) = x_0$ para que constituya un problema bien posado (*problema de valores iniciales*, o *problema de Cauchy*).\n", 53 | "La solución de una ecuación de este tipo será una *función* $x(t)$ que satisface al mismo tiempo que $\\dot{x}(t) = f(x(t), t)$ para cada $t$, y que $x(t=t_0) = x_0$. \n", 54 | "\n", 55 | "En el caso particular de la ecuación $\\dot{x} = -\\alpha x$, conocemos analíticamente la solución, y nos servirá para comprobar nuestros métodos. Pero para las ecuaciones de interés para la física, esto *casi nunca ocurre*, una situación que ¡suele pasar desapercibida durante la carrera! En estos casos, debemos aplicar distintas técnicas de *aproximación* de la solución, entre las cuales se destacan los *métodos numéricos*." 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "metadata": {}, 61 | "source": [ 62 | "# Método de Euler" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "Para resolver una EDO numéricamente en la computadora, tendremos que *aproximar* la solución continua $x: t \\mapsto x(t)$ con una versión con una cantidad finita de información, es decir, *discretizarla* de alguna forma.\n", 70 | "\n", 71 | "La manera más sencilla de hacerla es utilizando *diferencias finitas*. Empezaremos con el caso más sencillo, el llamado *método de Euler*." 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "#### Ejercicio 1\n", 79 | "\n", 80 | "(i) ¿Cuál es la aproximación más sencilla de la derivada $\\dot{x}(t)$, en términos de un tamaño de paso pequeño $h$?" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "(ii) Aplica esta aproximación con la ecuación $\\dot{x} = f(x, t)$ para obtener una expresión para $x(t+h)$, es decir el valor *predicho* en el siguiente *paso* de tiempo, en términos del valor ya conocido $x(t)$." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "(iii) Implementa un paso de este *método de Euler* en una función `paso_euler` para una función `f` cualquiera. ¿Cuáles argumentos debe tomar Euler? ¿Cuáles argumentos debe tomar `f`?" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": null, 114 | "metadata": {}, 115 | "outputs": [], 116 | "source": [] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "(iv) Ahora implementa el método de Euler completo en una función `euler`.\n", 123 | "Para hacerlo, crea un arreglo `ts` de los tiempos en los cuales se evaluará la función. Luego crea otro arreglo de ceros, con la función `zeros`. [Si pasas el arreglo `t` como argumento a esta función, creará un arreglo del mismo tamaño al poner `zeros(size(t))`.] Ahora implementa el paso (ii) en un algoritmo iterativo para actualizar los valores en el nuevo arreglo para cada tiempo sucesivamente." 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "(v) Verifica que funcione tu método al aplicarlo a una función $f(t)$ sencilla que dependa *únicamente del tiempo*. [Recuerda que debes imponer una condición inicial.] ¿Cuál operación matemática acabas de llevar a cabo? ¿Con cuál método? Compara con la solución analítica." 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": null, 143 | "metadata": {}, 144 | "outputs": [], 145 | "source": [] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "#### Ejercicio 2\n", 152 | "\n", 153 | "(i) Utiliza tu función `euler` para resolver la ecuación $\\dot{x} = -\\alpha x$, y compara tu solución numérica gráficamente con la solución analítica de la ecuación. ¿Qué pasa al variar el paso de tiempo? Hazlo interactivo." 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [] 162 | }, 163 | { 164 | "cell_type": "markdown", 165 | "metadata": {}, 166 | "source": [ 167 | "(ii) Dado que el método de Euler utiliza una aproximación, el resultado no es exacto. Fija una $t$ final y calcula el error (desde la solución analítica) en función del tamaño de paso $h$. ¿Cómo es la convergencia en función de $h$?" 168 | ] 169 | }, 170 | { 171 | "cell_type": "code", 172 | "execution_count": null, 173 | "metadata": {}, 174 | "outputs": [], 175 | "source": [] 176 | }, 177 | { 178 | "cell_type": "markdown", 179 | "metadata": {}, 180 | "source": [ 181 | "#### Ejercicio 3\n", 182 | "\n", 183 | "Considera la ecuación diferencial nolineal $\\dot{x} = x \\, (1-x)$, la cual modela la dinámica de una población; $x$ representa de alguna forma la densidad de población. \n", 184 | "\n", 185 | "(i) Dibuja el \"campo vectorial\" en el espacio $t$--$x$, es decir flechitas que indican en cuál dirección se camina en cada paso. \n", 186 | "\n", 187 | "[Pista: Utiliza la función `quiver`, con la sintaxis \n", 188 | "\n", 189 | " quiver(xs, ys, quiver=df)\n", 190 | " \n", 191 | "donde `xs` y `ys` especifican la posición del vector, y `df` es una función que toma un vector posición y regresa el vector que se coloca ahí.\n", 192 | "]" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": null, 198 | "metadata": {}, 199 | "outputs": [], 200 | "source": [] 201 | }, 202 | { 203 | "cell_type": "markdown", 204 | "metadata": {}, 205 | "source": [ 206 | "(ii) Resúelvela numéricamente la ecuación desde distintas condiciones iniciales (incluso las no-físicas) y dibuja las soluciones correspondientes. Interpreta el resultado de manera física (o biológica). " 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": null, 212 | "metadata": {}, 213 | "outputs": [], 214 | "source": [] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "#### Ejercicio 4" 221 | ] 222 | }, 223 | { 224 | "cell_type": "markdown", 225 | "metadata": {}, 226 | "source": [ 227 | "(i) Resuelve numéricamente la EDO\n", 228 | "$$ \\dot{x} = 1 + x^2. $$" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "(ii) Dibuja la trayectoria desde $x_0 = 0$. Fija los límites en $y$ de la gráfica. Agrega trayectorias desde algunas otras condiciones iniciales." 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": {}, 249 | "outputs": [], 250 | "source": [] 251 | }, 252 | { 253 | "cell_type": "markdown", 254 | "metadata": {}, 255 | "source": [ 256 | "(iii) ¿Qué ocurre? Compara este comportamiento con la solución analítica." 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": null, 262 | "metadata": {}, 263 | "outputs": [], 264 | "source": [] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "(iv) ¿Puedes integrar *hacia atrás* en el tiempo (hacia tiempos negativos)? ¿Qué ocurre?" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "## Dos variables" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "El método de Euler se puede extender directamente a EDOs con más de una variable." 292 | ] 293 | }, 294 | { 295 | "cell_type": "markdown", 296 | "metadata": {}, 297 | "source": [ 298 | "#### Ejercicio 5" 299 | ] 300 | }, 301 | { 302 | "cell_type": "markdown", 303 | "metadata": {}, 304 | "source": [ 305 | "(i) Escribe la ecuación diferencial que describe una caída libre (vertical) bajo gravedad." 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": null, 311 | "metadata": {}, 312 | "outputs": [], 313 | "source": [] 314 | }, 315 | { 316 | "cell_type": "markdown", 317 | "metadata": {}, 318 | "source": [ 319 | "(ii) Recuerda que hay un \"truco\" para reducir una ecuación diferencial de segundo orden a dos ecuaciones de primer orden; ¿cuál es? ¿Qué resulta en el caso del oscilador armónico amortiguado?" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": {}, 326 | "outputs": [], 327 | "source": [] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "(iii) Deriva un método de Euler para las ecuaciones acopladas\n", 334 | "\n", 335 | "$$\\dot{x} = f(x, y);$$\n", 336 | "$$\\dot{y} = g(x, y).$$\n", 337 | "\n", 338 | "Para hacerlo, aplica la definición de la derivada de nuevo." 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": null, 344 | "metadata": {}, 345 | "outputs": [], 346 | "source": [] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": {}, 351 | "source": [ 352 | "(iv) Implementa el método en una función `euler2`. ¿Cuáles argumentos debe tomar?" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": null, 358 | "metadata": {}, 359 | "outputs": [], 360 | "source": [] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": {}, 365 | "source": [ 366 | "(v) Resuelve la caída libre numéricamente y compara la solución con la analítica." 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": null, 372 | "metadata": {}, 373 | "outputs": [], 374 | "source": [] 375 | }, 376 | { 377 | "cell_type": "markdown", 378 | "metadata": {}, 379 | "source": [ 380 | "#### Ejercicio 6\n", 381 | "\n", 382 | "(i) Escribe la ecuación diferencial que describe un oscilador armónico amortiguado." 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": null, 388 | "metadata": {}, 389 | "outputs": [], 390 | "source": [] 391 | }, 392 | { 393 | "cell_type": "markdown", 394 | "metadata": {}, 395 | "source": [ 396 | "(ii) Utiliza `euler2` para calcular trayectorias desde distintas condiciones iniciales. Dibújalas, y ¡hazlo interactivo!\n", 397 | "\n", 398 | "Debes dibujar tanto $x(t)$ y $y(t)$ como funciones del tiempo, como el **espacio fase**. Dibuja también el campo vectorial en el espacio fase." 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": null, 404 | "metadata": {}, 405 | "outputs": [], 406 | "source": [] 407 | } 408 | ], 409 | "metadata": { 410 | "kernelspec": { 411 | "display_name": "Julia 1.0.3", 412 | "language": "julia", 413 | "name": "julia-1.0" 414 | }, 415 | "language_info": { 416 | "file_extension": ".jl", 417 | "mimetype": "application/julia", 418 | "name": "julia", 419 | "version": "1.0.3" 420 | } 421 | }, 422 | "nbformat": 4, 423 | "nbformat_minor": 1 424 | } 425 | -------------------------------------------------------------------------------- /notebooks/11. Interpolacion.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Interpolación" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "En el notebook anterior, vimos cómo se puede discretizar una función continua para calcular numéricamente una derivada.\n", 15 | "\n", 16 | "Un problema muy común en el cómputo científico es el problema opuesto: tenemos datos discretos, y queremos encontrar una función continua que los aproxime. Una manera de hacer esto es la **interpolación**: \n", 17 | "\n", 18 | "> Dados datos $(x_i, y_i)$ para $i=1,\\ldots,N$, encontrar una función $f(x)$ que pase exactamente por los puntos, es decir, tal que $f(x_i) = y_i$ para cada $i$.\n", 19 | "\n", 20 | "La interpolación provee, entre otras cosas, una manera de formalizar la derivación de diferencias finitas para calcular derivadas, y para llevar a cabo integrales de manera numérica. Mucho más allá, provee también una manera para manipular funciones de forma numérica.\n", 21 | "\n", 22 | "Podríamos escoger distintas clases de función $f$ con las cuales interpolar. Aquí, trabajaremos con los **polinomios** y la llamada **interpolación de Lagrange**." 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "#### Ejercicio 1\n", 30 | "\n", 31 | "El primer caso que tratar es con $N=2$, es decir encontrar una función que interpole entre los puntos $(x_1, y_1)$ y $(x_2, y_2)$. Es claro que basta utilizar una recta para hacerlo. Para encontrar cuál recta es, hacemos lo siguiente.\n", 32 | "\n", 33 | "(i) Define una función $L_1(x)$ que es lineal en $x$, tal que $L_1(x)$ tome el valor $0$ en $x = x_2$, es decir, $L_1(x_2) = 0$. Ahora haz que también tome el valor $1$ en $x = x_1$, es decir, que $L_1(x_1) = 1$." 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": null, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [] 42 | }, 43 | { 44 | "cell_type": "markdown", 45 | "metadata": {}, 46 | "source": [ 47 | "(ii) Por simetría, encuentra la función $L_2(x)$ tal que $L_2(x_1) = 0$ y $L_2(x_2) = 1$." 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": null, 53 | "metadata": {}, 54 | "outputs": [], 55 | "source": [] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "(iii) Utiliza $L_1$ y $L_2$ para encontrar un polinomio lineal que interpola los datos." 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": null, 67 | "metadata": {}, 68 | "outputs": [], 69 | "source": [] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "(iv) Impleméntalo." 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": null, 81 | "metadata": {}, 82 | "outputs": [], 83 | "source": [] 84 | }, 85 | { 86 | "cell_type": "markdown", 87 | "metadata": {}, 88 | "source": [ 89 | "(v) Toma dos puntos. Dibújalos y el polinomio lineal que los interpola." 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": null, 95 | "metadata": {}, 96 | "outputs": [], 97 | "source": [] 98 | }, 99 | { 100 | "cell_type": "markdown", 101 | "metadata": {}, 102 | "source": [ 103 | "#### Ejercicio 2\n", 104 | "\n", 105 | "Hagamos lo mismo con tres puntos:\n", 106 | "\n", 107 | "(i) Encuentra un polinomio $L_1(x)$ sencillo, tal que $L(x)$ sea igual a $0$ para $x=x_2$ y $x=x_3$. Ahora normalízalo para que $L_1(x_1) = 1$. ¿De qué grado es el polinomio?" 108 | ] 109 | }, 110 | { 111 | "cell_type": "code", 112 | "execution_count": null, 113 | "metadata": {}, 114 | "outputs": [], 115 | "source": [] 116 | }, 117 | { 118 | "cell_type": "markdown", 119 | "metadata": {}, 120 | "source": [ 121 | "(ii) De manera similar, encuentra $L_i(x)$ que sea igual a $1$ en $x_i$, y que se anule en $x_j$ para $j \\neq i$, para $i=2, 3$." 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": null, 127 | "metadata": {}, 128 | "outputs": [], 129 | "source": [] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "(iii) Implementa estas funciones como una función `L(i, x)` que toma $i$ y $x$ como argumentos y calcule la función $L_i$ evaluada en el punto $x$. " 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": null, 141 | "metadata": {}, 142 | "outputs": [], 143 | "source": [] 144 | }, 145 | { 146 | "cell_type": "markdown", 147 | "metadata": {}, 148 | "source": [ 149 | "(iv) Calcula la función $L(x)$ que interpola los tres puntos simultáneamente, basado en las funciones $L_i$ que acabas de encontrar. ¿Qué tipo de polinomio es?" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": null, 155 | "metadata": {}, 156 | "outputs": [], 157 | "source": [] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "(v) Escoge 3 puntos $(x_i, y_i)$. Dibújalos y dibuja la función $L$ que los interpola." 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": null, 169 | "metadata": {}, 170 | "outputs": [], 171 | "source": [] 172 | }, 173 | { 174 | "cell_type": "markdown", 175 | "metadata": {}, 176 | "source": [ 177 | "#### Ejercicio 3\n", 178 | "\n", 179 | "Ahora generalicemos esto a $N$ puntos:\n", 180 | "\n", 181 | "(i) Encuentra un polinomio $L_1(x)$ sencillo, tal que $L(x)$ sea igual a $0$ para $x=x_2$, $x=x_3$, \\ldots, $x=x_N$. Ahora normalízalo para que $L_1(x_1) = 1$. ¿De qué grado es el polinomio?" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": null, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [] 190 | }, 191 | { 192 | "cell_type": "markdown", 193 | "metadata": {}, 194 | "source": [ 195 | "(ii) De manera similar, encuentra $L_i(x)$ que sea igual a $1$ en $x_i$, y que se anule en $x_j$ para $j \\neq i$." 196 | ] 197 | }, 198 | { 199 | "cell_type": "markdown", 200 | "metadata": {}, 201 | "source": [ 202 | "(iii) Implementa estas funciones como una función `L(i, x)` que toma $i$ y $x$ como argumentos y calcule la función $L_i$ evaluada en el punto $x$. " 203 | ] 204 | }, 205 | { 206 | "cell_type": "code", 207 | "execution_count": null, 208 | "metadata": {}, 209 | "outputs": [], 210 | "source": [] 211 | }, 212 | { 213 | "cell_type": "markdown", 214 | "metadata": {}, 215 | "source": [ 216 | "(iv) Dibuja algunas $L_i$ como función de $x$ para $N$ chiquitas. Asegúrate de que sí se comporten correctamente, es decir que sí tomen los valores $1$ y $0$ en donde deben." 217 | ] 218 | }, 219 | { 220 | "cell_type": "code", 221 | "execution_count": null, 222 | "metadata": {}, 223 | "outputs": [], 224 | "source": [] 225 | }, 226 | { 227 | "cell_type": "markdown", 228 | "metadata": {}, 229 | "source": [ 230 | "#### Ejercicio 4\n", 231 | "\n", 232 | "(i) Utiliza las $L_i$ que encontraste en el ejercicio 2 para interpolar los datos $(x_i, y_i)_{i=1}^N$ con un polinomio $p$. ¿De qué orden es el polinomio resultante? Nota que $p$ es *único* en el conjunto de polinomios con grado $\\le$ el grado de $p$." 233 | ] 234 | }, 235 | { 236 | "cell_type": "code", 237 | "execution_count": null, 238 | "metadata": {}, 239 | "outputs": [], 240 | "source": [] 241 | }, 242 | { 243 | "cell_type": "markdown", 244 | "metadata": {}, 245 | "source": [ 246 | "(ii) Escribe una función `interpolar` que acepta un vector `x` de las $x_i$ y otro vector `y` de las $y_i$, y regresa *una función* que las interpole. [Pista: Puedes definir la función adentro de la función `interpolar` y regresar esta misma función.]" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": null, 252 | "metadata": {}, 253 | "outputs": [], 254 | "source": [] 255 | }, 256 | { 257 | "cell_type": "markdown", 258 | "metadata": {}, 259 | "source": [ 260 | "(iii) Toma funciones polinomiales de orden $n$ diferentes, y genera $n+1$ datos al *muestrear* (es decir, evaluar) la función en distintos puntos $x_i$, espaciados de forma uniforme. Dibuja la función original y la función interpolada en estos puntos." 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": null, 266 | "metadata": {}, 267 | "outputs": [], 268 | "source": [] 269 | }, 270 | { 271 | "cell_type": "markdown", 272 | "metadata": {}, 273 | "source": [ 274 | "(iv) Intenta interpolar la función $\\sin(x)$. ¿Funciona bien?" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": null, 280 | "metadata": {}, 281 | "outputs": [], 282 | "source": [] 283 | }, 284 | { 285 | "cell_type": "markdown", 286 | "metadata": {}, 287 | "source": [ 288 | "#### Ejercicio 5\n", 289 | "\n", 290 | "Considera la función de Runge, $f(x) = \\frac{1}{1+25x^2}$, en la región $x \\in [-1, 1]$. Interpólala con tu función `interpolar` para distintos números $N$ de puntos. ¿Qué observas? Utiliza `@manipulate` para variar el número de puntos muestreados / grado del polinomio interpolador." 291 | ] 292 | }, 293 | { 294 | "cell_type": "code", 295 | "execution_count": null, 296 | "metadata": {}, 297 | "outputs": [], 298 | "source": [] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "## Interpolación en puntos espaciados no-uniformemente" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": {}, 310 | "source": [ 311 | "Le que acabas de observar se llama el **fenómeno de Runge**. Esto demuestra que en general *es una mala idea* interpolar en puntos uniformemente espaciados. Sin embargo, resulta que el problema no es la interpolación en sí, sino la elección de puntos en donde interpolar: una solución es el tomar puntos en el intervalo $[-1,1]$, espaciados tales que se amontonen cerca de los puntos extremos del intervalo. [La razón por esto se puede entender con la teoría de potenciales (\"potential theory\"); ver e.g. Trefethen, *Approximation Theory and Approximation Practice*.] \n", 312 | "\n", 313 | "Lo más común es utilizar los llamados **puntos de Chebyshev** con parámetro $n$, definidos como \n", 314 | "\n", 315 | "$$x_j := \\cos \\left( \\frac{j \\pi}{n} \\right) \\quad \\text{con } 0 \\le j \\le n.$$" 316 | ] 317 | }, 318 | { 319 | "cell_type": "markdown", 320 | "metadata": {}, 321 | "source": [ 322 | "#### Ejercicio 6\n", 323 | "\n", 324 | "(i) Escribe una función que calcula los puntos de Chebyshev para un valor de $n$ dado." 325 | ] 326 | }, 327 | { 328 | "cell_type": "code", 329 | "execution_count": null, 330 | "metadata": {}, 331 | "outputs": [], 332 | "source": [] 333 | }, 334 | { 335 | "cell_type": "markdown", 336 | "metadata": {}, 337 | "source": [ 338 | "(ii) Escribe una función que interpola una función dada en los puntos de Chebyshev. Grafica los resultados." 339 | ] 340 | }, 341 | { 342 | "cell_type": "code", 343 | "execution_count": null, 344 | "metadata": {}, 345 | "outputs": [], 346 | "source": [] 347 | }, 348 | { 349 | "cell_type": "markdown", 350 | "metadata": {}, 351 | "source": [ 352 | "(iii) Interpola la función de Runge con puntos de Chebyshev. ¿Qué observas?" 353 | ] 354 | }, 355 | { 356 | "cell_type": "code", 357 | "execution_count": null, 358 | "metadata": {}, 359 | "outputs": [], 360 | "source": [] 361 | }, 362 | { 363 | "cell_type": "markdown", 364 | "metadata": {}, 365 | "source": [ 366 | "#### Ejercicio 7\n", 367 | "\n", 368 | "(i) Dada una función $f$, calcula numéricamente el error al utilizar la interpolación de Chebyshev $p$ con respecto a la función original $f$, dado por la norma\n", 369 | "\n", 370 | "$$\\|f - p\\|_{\\infty} := \\sup_x |f(x) - p(x)|,$$\n", 371 | "\n", 372 | "para distintos números de puntos de Chebyshev." 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": null, 378 | "metadata": {}, 379 | "outputs": [], 380 | "source": [] 381 | }, 382 | { 383 | "cell_type": "markdown", 384 | "metadata": {}, 385 | "source": [ 386 | "(ii) Conforme se aumenta el número de puntos, ¿cómo es la convergencia a $0$ del error? " 387 | ] 388 | }, 389 | { 390 | "cell_type": "code", 391 | "execution_count": null, 392 | "metadata": {}, 393 | "outputs": [], 394 | "source": [] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "metadata": {}, 399 | "source": [ 400 | "#### Ejercicio 8\n", 401 | "\n", 402 | "Resulta que la tasa de convergencia depende de qué tan suave sea la función.\n", 403 | "Por ejemplo, inténtalo con la función `abs` y con la función `floor`." 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": null, 409 | "metadata": {}, 410 | "outputs": [], 411 | "source": [] 412 | }, 413 | { 414 | "cell_type": "markdown", 415 | "metadata": {}, 416 | "source": [ 417 | "## Hacia el futuro" 418 | ] 419 | }, 420 | { 421 | "cell_type": "markdown", 422 | "metadata": {}, 423 | "source": [ 424 | "Lo que hemos logrado es reemplazar (aproximar) una función continua $f$ por un conjunto discreto de sus valores $f(x_i)$ en la **malla** $(x_i)_{i=1}^N$. Ahora podremos manipular la función ¡al manipular sólo estos valores discretos!" 425 | ] 426 | }, 427 | { 428 | "cell_type": "markdown", 429 | "metadata": {}, 430 | "source": [ 431 | "Resulta que es más útil cambiar de punto de vista, y utilizar la llamada [**interpolación baricéntrica**](https://people.maths.ox.ac.uk/trefethen/barycentric.pdf).\n", 432 | "\n", 433 | "Luego llevamos a cabo un **cambio de base** en el espacio de polinomios, y utilizamos los **polinomios de Chebyshev** en lugar de los polinomios basados en $x^i$.\n", 434 | "\n", 435 | "La idea es escribir el polinomio interpolante como una suma de polinomios de Chebyshev y examinar los coeficientes de estos polinomios, que tienen propiedades muy útiles. Esto lo podremos ver hasta después de ver álgebra lineal numérica. ¡Podría formar un proyecto final interesante! " 436 | ] 437 | } 438 | ], 439 | "metadata": { 440 | "kernelspec": { 441 | "display_name": "Julia 1.0.3", 442 | "language": "julia", 443 | "name": "julia-1.0" 444 | }, 445 | "language_info": { 446 | "file_extension": ".jl", 447 | "mimetype": "application/julia", 448 | "name": "julia", 449 | "version": "1.0.3" 450 | } 451 | }, 452 | "nbformat": 4, 453 | "nbformat_minor": 2 454 | } 455 | -------------------------------------------------------------------------------- /notebooks/16. Metodos tipo Runge-Kutta.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Métodos tipo Runge–Kutta para EDOs" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Consideremos la EDO\n", 15 | "\n", 16 | "$$\\dot{x}(t) = f(x(t), t) \\qquad (1).$$\n", 17 | "\n", 18 | "Queremos desarrollor métodos numéricos que aproximen mejor la solución exacta que el método de Euler, es decir, para los cuales el tamaño del error (local) sea $\\mathcal{O}(h^n)$ con $n > 2$." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "#### Ejercicio 1\n", 26 | "\n", 27 | "Como hemos visto con el método de Euler, dada una aproximación para la solución $x(t_0)$ en el tiempo $t_0$, queremos encontrar una aproximación para la solución $x(t_0 + h)$ en el siguiente paso.\n", 28 | "\n", 29 | "(i) Desarrolla $x(t + h)$ en una serie de Taylor, incluyendo explícitamente los términos hasta segundo orden. Para calcular $\\ddot{x}$, deriva la ecuación (1) con respecto a $t$. Nota que $f$ es una **función de dos variables**." 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "(ii) ¿A qué corresponde el método de Euler?" 44 | ] 45 | }, 46 | { 47 | "cell_type": "code", 48 | "execution_count": null, 49 | "metadata": {}, 50 | "outputs": [], 51 | "source": [] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "Es posible derivar métodos (llamados **métodos de Taylor**) que calculen explícitamente las derivadas de $f$, utilizando técnicas de **diferenciación algorítmica** (también llamado \"diferenciación automática\").\n", 58 | "\n", 59 | "En lugar de esto, estudiaremos los llamados **métodos de Runge-Kutta** (RK), los cuales utilizan una idea diferente: \n", 60 | "\n", 61 | "> Evaluar $f$ varias veces, posiblemente en distintos lugares, y tomar una combinación lineal de estas evaluaciones para *reproducir* la expansión de Taylor a diferentes órdenes.\n", 62 | "\n", 63 | "Veremos un par de métodos de Runge-Kutta **explícitos**, es decir, en los cuales no es necesario de resolver una ecuación no-lineal; este último corresponde a un método **implícito**, por ejemplo, el método de Euler hacia atrás." 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "#### Ejercicio 2\n", 71 | "\n", 72 | "Para entender la idea de los métodos RK, regresemos al método de Euler hacia atrás. Si $t_n$ son los nodos en donde aproximamos la solución, y $x_n$ los valores aproximados, entonces tenemos lo siguiente (que obtenemos al aproximar la integral):\n", 73 | "\n", 74 | "$$x_{n+1} = x_n + \\frac{h}{2} \\left[ f(x_n, t_n) + f(x_{n+1}, t_{n+1}) \\right] \\qquad (2).$$\n", 75 | "\n", 76 | "Para convertir esta ecuación implícita en un método de Runge–Kutta explícita, tomemos una *aproximación* de $f(x_{n+1})$, al utilizar... ¡un *paso de Euler*! \n", 77 | "\n", 78 | "En general, los métodos de Runge–Kutta consisten en llevar a cabo varios pasos de Euler, que pueden ser de distintos tamaños.\n", 79 | "\n", 80 | "(i) Escribe la ecuación de un paso de Euler para $x_{n+1}$ en términos de $x_n$." 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": null, 86 | "metadata": {}, 87 | "outputs": [], 88 | "source": [] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "(ii) Inserte ese paso de Euler en la ecuación (2). Expande en potencias de $h$ hasta segundo orden. Demuestra que recupera la expansión de Taylor de $x(t_n+h)$ a segundo orden. Este método se llama el **método de Euler modificado**." 95 | ] 96 | }, 97 | { 98 | "cell_type": "code", 99 | "execution_count": null, 100 | "metadata": {}, 101 | "outputs": [], 102 | "source": [] 103 | }, 104 | { 105 | "cell_type": "markdown", 106 | "metadata": {}, 107 | "source": [ 108 | "(iii) Una alternativa es el tomar un paso de Euler en todo el intervalo de tamaño $h$, pero utilizando una mejor aproximación de la derivada en el intervalo. Para hacerlo, se toma un primer paso de Euler hasta la *mitad* del camino entre $t_n$ y $t_{n+1}$, es decir una \"distancia\" $h/2$ en el tiempo, y se evalúa ahí $f(x(t+h/2), t+h/2)$. Este valor luego se utiliza como la aproximación de $\\dot{x}$ sobre el intervalo en otro paso de Euler. Este método se llama el **método del punto medio**.\n", 109 | "\n", 110 | "Demuestra que también recupera la expansión de Taylor de $x(t_n+h)$ a segundo orden." 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "(iv) Implementa funciones para pasos individuales de estos dos métodos, para una EDO escalar (es decir, para una sola variable dependiente)." 125 | ] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [] 133 | }, 134 | { 135 | "cell_type": "markdown", 136 | "metadata": {}, 137 | "source": [ 138 | "(v) Implementa funciones para pasos individuales de estos dos métodos, de forma vectorial." 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "#### Ejercicio 3\n", 153 | "\n", 154 | "Para poder comparar distintos métodos, es útil contar con un integrador de EDOs más *general*, con el cual podamos escoger *cuál método utilizar* para los pasos.\n", 155 | "\n", 156 | "(i) Escribe una función `integrar` que integra una EDO con un tipo de paso dado. Como primer argumento, debe aceptar un argumento `método`, el cual corresponde al nombre de la función que se ejecutará en cada paso de la integración." 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": null, 162 | "metadata": {}, 163 | "outputs": [], 164 | "source": [] 165 | }, 166 | { 167 | "cell_type": "markdown", 168 | "metadata": {}, 169 | "source": [ 170 | "(ii) Utiliza la función `integrar` para integrar una EDO sencilla escalar con el método de Euler, el método de Euler modificado, y el método del punto medio. Compara las tasas de convergencia de los métodos." 171 | ] 172 | }, 173 | { 174 | "cell_type": "code", 175 | "execution_count": null, 176 | "metadata": {}, 177 | "outputs": [], 178 | "source": [] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "## Runga–Kutta de más alto orden" 185 | ] 186 | }, 187 | { 188 | "cell_type": "markdown", 189 | "metadata": {}, 190 | "source": [ 191 | "Se pueden derivar métodos de Runge–Kutta de más alto orden, es decir, siempre con la meta de reproducir la expansión de Taylor de $x(t+h)$ a cada vez más alto orden. Sin embargo, los cálculos se vuelven bastante complicados." 192 | ] 193 | }, 194 | { 195 | "cell_type": "markdown", 196 | "metadata": {}, 197 | "source": [ 198 | "#### Ejercicio 4\n", 199 | "\n", 200 | "(i) Uno de los métodos de Runge–Kutta más utilizados es el llamado **RK4**, que es de cuarto orden. Encuentra las ecuaciones para este método e impleméntalo para el caso de una ecuación EDO escalar." 201 | ] 202 | }, 203 | { 204 | "cell_type": "code", 205 | "execution_count": null, 206 | "metadata": {}, 207 | "outputs": [], 208 | "source": [] 209 | }, 210 | { 211 | "cell_type": "markdown", 212 | "metadata": {}, 213 | "source": [ 214 | "(ii) Implementa un paso de RK4 para una ecuación EDO vectorial." 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "(iii) Utiliza `integrar` para comparar su tasa de convergencia y compáralo visualmente con los demás métodos." 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": null, 234 | "metadata": {}, 235 | "outputs": [], 236 | "source": [] 237 | }, 238 | { 239 | "cell_type": "markdown", 240 | "metadata": {}, 241 | "source": [ 242 | "## Paso adaptativo" 243 | ] 244 | }, 245 | { 246 | "cell_type": "markdown", 247 | "metadata": {}, 248 | "source": [ 249 | "Hasta ahora, en todas las integraciones de EDOs que hemos hecho, ha habido un tamaño de paso fijo, que es un parámetro que pasamos a la función `RK4` etc.\n", 250 | "\n", 251 | "Pero surge una pregunta: ¿cómo se debe escoger el tamaño del paso? (Seguro ¡has pasado por esta pregunta!) La respuesta dependerá de la función $\\mathbf{f}$ que estemos integrando: si $\\mathbf{f}$ cambia rápido, debemos usar un paso más chiquito para resolver los cambios; si cambia más lentamente, podemos utilizar un paso más grande. \n", 252 | "\n", 253 | "El problema es que ¡sólo podemos saber qué tan rápido varía la función en medio de la integración misma!\n", 254 | "La solución es utilizar un método *adaptativo*: el método mismo tiene (cierto) control del tamaño de paso, el cual *se irá cambiando de manera automática* para tomar en cuenta la propia tasa de cambio de la función.\n", 255 | "\n", 256 | "Por esta razón, (casi) *nunca* se deberían utilizar los métodos simples y no-adaptativos como Euler y RK4 en la práctica." 257 | ] 258 | }, 259 | { 260 | "cell_type": "markdown", 261 | "metadata": {}, 262 | "source": [ 263 | "## Euler adaptativo " 264 | ] 265 | }, 266 | { 267 | "cell_type": "markdown", 268 | "metadata": {}, 269 | "source": [ 270 | "Dado que este tema se puede volver complicado, consideremos el método de Euler por simplicidad. Queremos resolver \n", 271 | "\n", 272 | "$$\\dot{x} = f(x),$$\n", 273 | "\n", 274 | "y tenemos\n", 275 | "\n", 276 | "$$x_{n+1} = x_n + h \\, f(x_n) + \\epsilon_1(h), \\qquad (3)$$\n", 277 | "\n", 278 | "donde $\\epsilon_1(h) = C \\, h^2$ es el error de un paso.\n", 279 | "Aquí, hemos supuesto que $C$ no depende de $h$. Esto no es realmente cierto (¿por qué?), pero facilita el cálculo.\n", 280 | "\n", 281 | "Para ciertos tipos de función $f$ (¿cuáles? -- ¿qué otra forma podríamos utilizar para el término del error?), el término del error será grande.\n", 282 | "¿Cómo podemos *estimar* el tamaño de este término?\n", 283 | "\n", 284 | "Una idea es el de tomar *dos* pasos, de tamaño $h/2$." 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "#### Ejercicio 5\n", 292 | "\n", 293 | "(i) Encuentra la expresión para $x_n$ si se toman dos pasos de tamaño $h/2$, \n", 294 | "donde $x_{n+\\frac{1}{2}}$ es el lugar intermedio.\n", 295 | "Substrae los dos resultados del método de Euler para encontrar el tamaño del error $\\epsilon$." 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [] 304 | }, 305 | { 306 | "cell_type": "markdown", 307 | "metadata": {}, 308 | "source": [ 309 | "Si $\\epsilon < \\mathrm{tol}$, una cierta tolerancia que imponemos, entonces el paso es exitoso, y actualizamos las variables. En este caso, la función está variando lentamente, así que podemos *incrementar* el tamaño del paso. \n", 310 | "Si no es exitoso, reducimos la tolerancia. En los dos casos, podemos actualizar según una regla de la forma\n", 311 | "\n", 312 | "$$ h' = 0.9 h \\, \\frac{\\mathrm{tol}}{|\\epsilon|}.$$" 313 | ] 314 | }, 315 | { 316 | "cell_type": "markdown", 317 | "metadata": {}, 318 | "source": [ 319 | "(ii) ¿Por qué funciona esta fórmula tanto cuando el paso tuvo éxito, como cuando no fue así?" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": {}, 326 | "outputs": [], 327 | "source": [] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "(iii) Implementa un método adaptativo de Euler. Nota que será necesario escribir una nueva función `integrar_adaptivo` que maneje los cambios del tamaño del paso." 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": null, 339 | "metadata": {}, 340 | "outputs": [], 341 | "source": [] 342 | }, 343 | { 344 | "cell_type": "markdown", 345 | "metadata": {}, 346 | "source": [ 347 | "(iv) Prúebalo para un sistema que hemos estudiado en el cual fracasa Euler. ¿Ayuda?" 348 | ] 349 | }, 350 | { 351 | "cell_type": "code", 352 | "execution_count": null, 353 | "metadata": {}, 354 | "outputs": [], 355 | "source": [] 356 | }, 357 | { 358 | "cell_type": "markdown", 359 | "metadata": {}, 360 | "source": [ 361 | "## Métodos de Runge-Kutta adaptativos " 362 | ] 363 | }, 364 | { 365 | "cell_type": "markdown", 366 | "metadata": {}, 367 | "source": [ 368 | "Supongamos que hiciéramos la misma idea para Runge-Kutta 4." 369 | ] 370 | }, 371 | { 372 | "cell_type": "markdown", 373 | "metadata": {}, 374 | "source": [ 375 | "#### Ejercicio 6\n", 376 | "\n", 377 | "¿Cuántas evaluaciones de la función $f$ se requieren para llevar a cabo un paso de tamaño $h$?" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": null, 383 | "metadata": {}, 384 | "outputs": [], 385 | "source": [] 386 | }, 387 | { 388 | "cell_type": "markdown", 389 | "metadata": {}, 390 | "source": [ 391 | "Dado que esto puede ser caro, hay una mejor solución. Resulta que hay métodos de Runge-Kutta llamados \"embedded\" (\"embebido\") tales que podemos utilizar las *mismas* evaluaciones de la función $f$ (en los mismos lugares del intervalo $[t, t+h]$), y nos proporciona ¡*dos* estimados diferentes de $x(t+h)$, con dos órdenes de error distintos! Esto se puede aplicar de la misma forma para controlar el tamaño de paso, pero con menos evaluaciones de $f$ en cada paso que tomar dos pasos de tamaño $h/2$.\n", 392 | "\n", 393 | "Este método, y otros parecidos, es uno de los que se suele utilizar para cálculos serios." 394 | ] 395 | }, 396 | { 397 | "cell_type": "markdown", 398 | "metadata": {}, 399 | "source": [ 400 | "#### Ejercicio 7 (opcional) \n", 401 | "\n", 402 | "Implementa un método de Runge– adaptativo, por ejemplo el método \"RK45\" (Runge–Kutta–Fehlberg), que mezcla un método de 4o. y de 5o. orden. Alternativamente hay métodos de orden 2–3.\n", 403 | "Verifica su orden de convergencia." 404 | ] 405 | }, 406 | { 407 | "cell_type": "code", 408 | "execution_count": null, 409 | "metadata": {}, 410 | "outputs": [], 411 | "source": [] 412 | } 413 | ], 414 | "metadata": { 415 | "kernelspec": { 416 | "display_name": "Julia 1.0.3", 417 | "language": "julia", 418 | "name": "julia-1.0" 419 | }, 420 | "language_info": { 421 | "file_extension": ".jl", 422 | "mimetype": "application/julia", 423 | "name": "julia", 424 | "version": "1.0.3" 425 | } 426 | }, 427 | "nbformat": 4, 428 | "nbformat_minor": 1 429 | } 430 | -------------------------------------------------------------------------------- /notebooks/03. Iteracion con for.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Iteración" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Las computadoras están diseñadas para llevar a cabo cálculos de forma repetida. En Julia, existen varias formas de llevar a cabo cálculos repetidos. Uno de los más sencillos es la **iteración**. Esto se refiere a que una variable recorra un conjunto de valores, uno por uno, a través de un **bucle** (ciclo, loop).\n", 15 | "\n", 16 | "Empezaremos con los bucles llamados `for` (\"para\", en español).\n", 17 | "\n", 18 | "Ya hemos visto las comprensiones de arreglo, que proveen una forma sencilla y rápida para crear arreglos, y ocupan la palabra `for`. Los bucles `for` proveen una manera más precisa para llevar a cabo tareas de forma repetitiva." 19 | ] 20 | }, 21 | { 22 | "cell_type": "markdown", 23 | "metadata": {}, 24 | "source": [ 25 | "## `for`" 26 | ] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "Un bucle `for` itera a través de un arreglo, rango etc. (cualquier objeto \"iterable\", de hecho). Su sintaxis es:\n", 33 | "\n", 34 | "```\n", 35 | "for in \n", 36 | " [haz esto]\n", 37 | " [y esto]\n", 38 | "end\n", 39 | "```\n", 40 | "\n", 41 | "En un bucle de este tipo, la variable toma cada valor en turno del arreglo. Se refiere a los comandos adentro como el \"cuerpo\" del bucle. Estos comandos se ejecutarán una y otra vez, hasta que se agote el iterable.\n", 42 | "\n", 43 | "Por lo tanto, este tipo de bucle se ocupa cuando se conoce de antemano el número de veces que se requiera repetir algo.\n", 44 | "\n", 45 | "El ejemplo más sencillo es el siguiente:" 46 | ] 47 | }, 48 | { 49 | "cell_type": "code", 50 | "execution_count": null, 51 | "metadata": {}, 52 | "outputs": [], 53 | "source": [ 54 | "for i in 1:10\n", 55 | " println(\"El valor actual de i es \", i)\n", 56 | "end" 57 | ] 58 | }, 59 | { 60 | "cell_type": "markdown", 61 | "metadata": {}, 62 | "source": [ 63 | "Vemos que la variable `i` toma cada valor en el rango, de 1 hasta 10, uno por uno. Literalmente lo podemos leer como sigue: \"Para cada `i` en el conjunto de valores 1 hasta 10, haz las siguientes operaciones\". Aquí, \"las siguientes operaciones\" se refiere a todos los comandos comprendidos entre el `for` y el `end` correspondiente." 64 | ] 65 | }, 66 | { 67 | "cell_type": "markdown", 68 | "metadata": {}, 69 | "source": [ 70 | "#### Ejercicio 1\n", 71 | "Escribe el código a mano para llevar a cabo lo mismo, *sin* utilizar un bucle. ¿Quisieras hacerlo para los números de 1 a 100? ¡Por algo se inventaron los bucles!" 72 | ] 73 | }, 74 | { 75 | "cell_type": "code", 76 | "execution_count": null, 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "En este ejemplo, se iteró sobre un objeto de tipo rango. También se puede iterar sobre un vector:" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "x = [3, 4, 7]\n", 95 | "\n", 96 | "for i in x\n", 97 | " println(i)\n", 98 | "end" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "#### Ejercicio 2\n", 106 | "\n", 107 | "Sabemos que la multiplicación por un entero es como una adición repetida. \n", 108 | "\n", 109 | "(i) Define una variable `a` igual a 3 y `n` igual a 10. Escribe un bucle `for` que multiplica `a` por `n` a través de adición repetida, sin modificar los valores ni de `a` ni de `n`. Para hacerlo, utiliza una variable nueva que se llama `total`. ¿Con cuál valor inicial se debe crear esta variable? ¿Por qué? Verifica que tu función dé el resultado correcto." 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": null, 115 | "metadata": {}, 116 | "outputs": [], 117 | "source": [] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "(ii) Inserta tu código adentro de una función `mi_mult` que tome `a` y `n` como argumentos." 124 | ] 125 | }, 126 | { 127 | "cell_type": "code", 128 | "execution_count": null, 129 | "metadata": {}, 130 | "outputs": [], 131 | "source": [] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "metadata": {}, 136 | "source": [ 137 | "#### Ejercicio 3\n", 138 | "(i) Crea una función `mi_suma` que calcula la suma de los primeros $N$ enteros utilizando un bucle `for`. " 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [] 147 | }, 148 | { 149 | "cell_type": "markdown", 150 | "metadata": {}, 151 | "source": [ 152 | "(ii) Crea una función `mi_suma2` que calcula, en un solo bucle, la suma de los primeros $N$ enteros, y de sus cuadrados. Regresa las dos sumas. [Pista: Puedes regresar dos valores con `return x, y`.] Verifica que funcione utilizando la fórmula para la suma de los cuadrados." 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": null, 158 | "metadata": {}, 159 | "outputs": [], 160 | "source": [] 161 | }, 162 | { 163 | "cell_type": "markdown", 164 | "metadata": {}, 165 | "source": [ 166 | "## Condicionales" 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "A menudo, necesitamos checar si una condición se satisface, y llevar a cabo acciones distintas dependiendo de si sí o no se tiene la condición. Esto se hace con una estructura `if` (\"si\"). Por ejemplo:" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": null, 179 | "metadata": {}, 180 | "outputs": [], 181 | "source": [ 182 | "a = 3\n", 183 | "\n", 184 | "if a > 4\n", 185 | " println(\"$a es grande\")\n", 186 | "end" 187 | ] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "Podemos agregar una serie de condiciones que verificar con `elseif` y `else` (\"sino\")" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": null, 199 | "metadata": {}, 200 | "outputs": [], 201 | "source": [ 202 | "a = 3\n", 203 | "\n", 204 | "if a < 4\n", 205 | " println(\"$a es chico\")\n", 206 | " \n", 207 | "elseif a < 10\n", 208 | " println(\"$a es mediano\")\n", 209 | " \n", 210 | "else\n", 211 | " println(\"$a es grande\")\n", 212 | "end" 213 | ] 214 | }, 215 | { 216 | "cell_type": "markdown", 217 | "metadata": {}, 218 | "source": [ 219 | "#### Ejercicio 4\n", 220 | "(i) Pon este código adentro de una función. ¿Cuál argumento necesita la función? Pruébalo con distintos números." 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": null, 226 | "metadata": {}, 227 | "outputs": [], 228 | "source": [] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "(ii) Escribe una función para calcular el valor absoluto $|a|$ de un número real $a$, utilizando un `if` y `else`, tomando en cuenta el valor 0 explícitamente." 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": null, 240 | "metadata": {}, 241 | "outputs": [], 242 | "source": [] 243 | }, 244 | { 245 | "cell_type": "markdown", 246 | "metadata": {}, 247 | "source": [ 248 | "### Condiciones útiles" 249 | ] 250 | }, 251 | { 252 | "cell_type": "markdown", 253 | "metadata": {}, 254 | "source": [ 255 | "Podemos utilizar `<`, `<=` o `≤` (`\\le`), `>=` y `≥` (`\\ge`) en condicionales. También podemos utilizar\n", 256 | "\n", 257 | "- \"`==`\" para verificar igualdad de dos cantidades (nota bien la diferencia con el operador de asignación, `=`)\n", 258 | "\n", 259 | "- \"`!=`\" para verificar que dos cantidades sean distintas\n", 260 | "\n", 261 | "Para verificar divisibilidad, podemos utilizar el operador `%` (módulo): `a % b` calcula el remanente al dividir `a` entre `b`." 262 | ] 263 | }, 264 | { 265 | "cell_type": "markdown", 266 | "metadata": {}, 267 | "source": [ 268 | "#### Ejercicio 5\n", 269 | "\n", 270 | "Escribe una función que regrese `true` (verdadero) si un número `n` es divisible entre 2 o entre 5, y `false` si no.\n" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": null, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [] 279 | }, 280 | { 281 | "cell_type": "markdown", 282 | "metadata": {}, 283 | "source": [ 284 | "## Creando arreglos usando iteración" 285 | ] 286 | }, 287 | { 288 | "cell_type": "markdown", 289 | "metadata": {}, 290 | "source": [ 291 | "Muchas veces es útil crear datos mediante una iteración. Almacenaremos los datos en un arreglo, pero no sabemos, en general, qué tan grande debe ser el arreglo.\n", 292 | "\n", 293 | "Por lo tanto, podemos empezar con un arreglo vacío e **ir agregando** los datos conforme vayan llegando.\n", 294 | "\n", 295 | "Para crear un arreglo vacío en Julia, usamos" 296 | ] 297 | }, 298 | { 299 | "cell_type": "code", 300 | "execution_count": null, 301 | "metadata": {}, 302 | "outputs": [], 303 | "source": [ 304 | "v = Int[]" 305 | ] 306 | }, 307 | { 308 | "cell_type": "markdown", 309 | "metadata": {}, 310 | "source": [ 311 | "La palabra `Int` al principio le dice a Julia que este arreglo sólo puede contener objetos de tipo `Int`." 312 | ] 313 | }, 314 | { 315 | "cell_type": "markdown", 316 | "metadata": {}, 317 | "source": [ 318 | "#### Ejercicio 6\n", 319 | "¿Qué ocurre si no ponemos `Int`? " 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": {}, 326 | "outputs": [], 327 | "source": [] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "Para agregar un dato al arreglo, se utiliza la función `push!`. (El \"`!`\" forma parte del nombre de la función. Indica que la función modifica su argumento.)" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": null, 339 | "metadata": {}, 340 | "outputs": [], 341 | "source": [ 342 | "push!(v, 17)" 343 | ] 344 | }, 345 | { 346 | "cell_type": "code", 347 | "execution_count": null, 348 | "metadata": {}, 349 | "outputs": [], 350 | "source": [ 351 | "v" 352 | ] 353 | }, 354 | { 355 | "cell_type": "markdown", 356 | "metadata": {}, 357 | "source": [ 358 | "#### Ejercicio 7\n", 359 | "(i) Utiliza este método para crear un arreglo que contenga los números de 1 a 100." 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": null, 365 | "metadata": {}, 366 | "outputs": [], 367 | "source": [] 368 | }, 369 | { 370 | "cell_type": "markdown", 371 | "metadata": {}, 372 | "source": [ 373 | "(ii) ¿Cómo puedes modificar tu código para excluir a los valores que son divisibles o entre 2 o entre 5?" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": null, 379 | "metadata": {}, 380 | "outputs": [], 381 | "source": [] 382 | }, 383 | { 384 | "cell_type": "markdown", 385 | "metadata": {}, 386 | "source": [ 387 | "## Números primos" 388 | ] 389 | }, 390 | { 391 | "cell_type": "markdown", 392 | "metadata": {}, 393 | "source": [ 394 | "Recordemos que los números primos son los enteros positivos mayores que $1$ que sólo son divisibles exactamente entre $1$ y sí mismo." 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": {}, 400 | "source": [ 401 | "#### Ejercicio 8\n", 402 | "(i) Escribe una función que verifica si un número es primo o no." 403 | ] 404 | }, 405 | { 406 | "cell_type": "code", 407 | "execution_count": null, 408 | "metadata": {}, 409 | "outputs": [], 410 | "source": [] 411 | }, 412 | { 413 | "cell_type": "markdown", 414 | "metadata": {}, 415 | "source": [ 416 | "(ii) Escribe una función que construye un arreglo de $\\pi(n)$, el número de primos menores o iguales a `n`. " 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": null, 422 | "metadata": {}, 423 | "outputs": [], 424 | "source": [] 425 | }, 426 | { 427 | "cell_type": "markdown", 428 | "metadata": {}, 429 | "source": [ 430 | "(iii) Grafica la función $\\pi(n)$ como función de $n$." 431 | ] 432 | }, 433 | { 434 | "cell_type": "code", 435 | "execution_count": null, 436 | "metadata": {}, 437 | "outputs": [], 438 | "source": [] 439 | }, 440 | { 441 | "cell_type": "markdown", 442 | "metadata": {}, 443 | "source": [ 444 | "(iv) ¿Qué tan rápido crece esta función en comparación con `n`?" 445 | ] 446 | }, 447 | { 448 | "cell_type": "code", 449 | "execution_count": null, 450 | "metadata": {}, 451 | "outputs": [], 452 | "source": [] 453 | }, 454 | { 455 | "cell_type": "markdown", 456 | "metadata": {}, 457 | "source": [ 458 | "## Visualizaciones interactivas" 459 | ] 460 | }, 461 | { 462 | "cell_type": "markdown", 463 | "metadata": {}, 464 | "source": [ 465 | "Una manera sumamente útil para extraer más información de un conjunto de datos es al visualizarlos de forma interactiva, cambiando algún(os) parámetro(s). Julia provee el paquete `Interact.jl` para esto." 466 | ] 467 | }, 468 | { 469 | "cell_type": "markdown", 470 | "metadata": {}, 471 | "source": [ 472 | "#### Ejercicio 9\n", 473 | "(i) Instala el paquete `Interact.jl`." 474 | ] 475 | }, 476 | { 477 | "cell_type": "code", 478 | "execution_count": null, 479 | "metadata": {}, 480 | "outputs": [], 481 | "source": [] 482 | }, 483 | { 484 | "cell_type": "markdown", 485 | "metadata": {}, 486 | "source": [ 487 | "(ii) Cárgalo." 488 | ] 489 | }, 490 | { 491 | "cell_type": "code", 492 | "execution_count": null, 493 | "metadata": {}, 494 | "outputs": [], 495 | "source": [] 496 | }, 497 | { 498 | "cell_type": "markdown", 499 | "metadata": {}, 500 | "source": [ 501 | "El paquete provee un macro (un tipo de \"super-función\") `@manipulate`. Al anteponer `@manipulate` ante un bucle `for`, convierte el bucle en una visualización con un slider:" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": null, 507 | "metadata": {}, 508 | "outputs": [], 509 | "source": [ 510 | "@manipulate for i in 1:10\n", 511 | " i\n", 512 | "end" 513 | ] 514 | }, 515 | { 516 | "cell_type": "markdown", 517 | "metadata": {}, 518 | "source": [ 519 | "(iii) Retoma la visualización del tiro parabólico del notebook anterior y haz una visualización interactiva al cambiar el ángulo inicial." 520 | ] 521 | }, 522 | { 523 | "cell_type": "code", 524 | "execution_count": null, 525 | "metadata": {}, 526 | "outputs": [], 527 | "source": [] 528 | } 529 | ], 530 | "metadata": { 531 | "kernelspec": { 532 | "display_name": "Julia 1.0.3", 533 | "language": "julia", 534 | "name": "julia-1.0" 535 | }, 536 | "language_info": { 537 | "file_extension": ".jl", 538 | "mimetype": "application/julia", 539 | "name": "julia", 540 | "version": "1.0.3" 541 | } 542 | }, 543 | "nbformat": 4, 544 | "nbformat_minor": 2 545 | } 546 | --------------------------------------------------------------------------------