proyectos-2017-1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h1 align=\"center\">Programación Científica en Python</h1>\n",
    "<h2 align=\"center\">Descripción de Proyectos</h2> "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para los proyectos descritos a continuación, los tres componentes siguientes serán evaluados con igual ponderación:\n",
    "\n",
    "1. __Implementación__: Código generado para la implementación, usando _algunas_ de las herramientas aprendidas en este curso.\n",
    "2. __Profiling__: Mediciones de la _performance_ de su solución al problema.\n",
    "3. __Visualización__: Visualización de los resultados utilizando `Matplotlib`.\n",
    "\n",
    "En cualquier caso usted es libre de diseñar los _experimentos_, _mediciones de performance_ y de los _resultados y gráficos_ a mostrar."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1.- Cellular Automaton: Conway's Game of Life\n",
    "\n",
    "El _Juego de la Vida_ es una aplicación de autómatas celulares (conjunto de reglas), para simular la formación de patrones en el crecimiento de colonias de organismos biológicos.\n",
    "\n",
    "\n",
    "Este juego se representa por medio de un arreglo bi-dimensional de __células vivas__ y __células muertas__. Las reglas para pasar de una generación a la otras son las siguientes (_Existen diferentes variaciones, pero estas son las más comunes_):\n",
    "\n",
    "* __Sobrepoblación__: Si una célula viva es rodeada por más de tres células vivas, muere.\n",
    "* __Estasis__: Si una célula viva es rodeada por dos o tres células vivas, sobrevive.\n",
    "* __Subpoblación__: Si una célula viva es rodeada por menos de dos células vivas, muere.\n",
    "* __Reproduction__: Si una célula muerta es rodeada por exáctamente tres células vivas, esta se vuelve una célula viva.\n",
    "\n",
    "Aquí cada célula es representada como un píxel en una grilla/arreglo bi-dimensional.\n",
    "\n",
    "Para más información visitar los siguientes links:\n",
    "* [https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life](https://en.wikipedia.org/wiki/Conway%27s_Game_of_Life)\n",
    "* [https://jakevdp.github.io/blog/2013/08/07/conways-game-of-life/](https://jakevdp.github.io/blog/2013/08/07/conways-game-of-life/)\n",
    "* [https://bitstorm.org/gameoflife/](https://bitstorm.org/gameoflife/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2.- Dynamic Systems: N-body Simulation\n",
    "\n",
    "Este consiste en la simulación numérica de un sistem de N EDOs (Ecuaciones Diferenciales Ordinarias), que representan la dinámica de movimiento de un sistema de N partículas interactuando entre sí, como por ejemplo, en la interacción gravitacional de planetas y estrellas.\n",
    "\n",
    "Sean un conjunto de $N$ cuerpos con masas $\\{m_1, m_2, \\ldots, m_N \\}$, posiciones (2D) $\\{\\mathbf{x_1}, \\mathbf{x_2}, \\ldots, \\mathbf{x_N} \\}$ y velocidades $\\{\\mathbf{v_1}, \\mathbf{v_2}, \\ldots, \\mathbf{v_N}\\}$, que interactúan gravitacionalmente de acuerdo a la __Ley de Gravitación Universal__:\n",
    "$$\n",
    "    \\mathbf{F_{ij}} = G \\frac{m_i m_j}{|| \\mathbf{x_j} - \\mathbf{x_i} ||^3}(\\mathbf{x_j} - \\mathbf{x_i}),\n",
    "$$\n",
    "correspondiente a la fuerza ejercida __sobre__ el cuerpo `i`, __por__ el cuerpo `j`. Entonces la dinámica del sistema viene descrita por la siguiente ecuación de movimiento (2da Ley de Newton):\n",
    "$$\n",
    "    m_i \\frac{d}{dt} \\mathbf{v_i} = m_i \\frac{d^2}{dt^2}\\mathbf{x_i} = \\sum_{j\\neq i}^{N} \\mathbf{F_{ij}} = \\sum_{j \\neq i}^{N} G \\frac{m_i m_j}{|| \\mathbf{x_j} - \\mathbf{x_i} ||^3}(\\mathbf{x_j} - \\mathbf{x_i})\n",
    "$$\n",
    "\n",
    "Para el caso 2D: $\\mathbf{x_i} = (x_i, y_j)$, $\\mathbf{v_i} = (v_{x_i}, v_{y_i})$ y las ecuaciones que describen el movimiento quedan:\n",
    "$$\n",
    "  \\frac{d^2}{dt^2}x_i = \\frac{d}{dt}v_{x_i} = G \\ \\sum_{j\\neq i}^{N}\\frac{m_j}{(x_j-x_i)^2} = H(x_i)\n",
    "$$\n",
    "\n",
    "$$  \n",
    "  \\frac{d^2}{dt^2}y_i = \\frac{d}{dt}v_{y_i} = G \\ \\sum_{j\\neq i}^{N}\\frac{m_j}{(y_j-y_i)^2} = H(y_i)\n",
    "$$\n",
    "\n",
    "Se requiere resolver __numéricamente__ la EDO para cada partícula del sistema. Para ello en cada componente de $\\mathbf{x_i}$ y $\\mathbf{v_i}$, se utiliza el método de Euler del siguiente modo ($\\Delta t$ _time step_ y $k$ número de iteración):\n",
    "$$\n",
    "\\Rightarrow v_{x_i}^{(k+1)} = H(x_i^{(k)}) \\Delta t + v_{x_i}^{(k)} \n",
    "$$\n",
    "$$\n",
    "x_i^{(k+1)} = v_{x_i}^{(k+1)} \\Delta t + x_i^{(k)} \n",
    "$$\n",
    "\n",
    "\n",
    "$$\n",
    "\\Rightarrow v_{y_i}^{(k+1)} = H(y_i^{(k)}) \\Delta t + v_{y_i}^{(k)}\n",
    "$$\n",
    "$$\n",
    "y_i^{(k+1)} = v_{y_i}^{(k+1)} \\Delta t + y_i^{(k)}\n",
    "$$\n",
    "  \n",
    "(Primero se actualiza la velocidad, luego la posición). Estas dos iteraciones deben llevarse a cabo para todas las partículas del sistema, partiendo de condiciones iniciales $(x_i^0, y_i^0)$ y $(v_{x_i}^0, v_{y_i}^0)$ para todas las partículas."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}