exit()

diff --git a/clases/02-12 Bindings.ipynb b/clases/02-12 Bindings.ipynb
new file mode 100644
index 0000000..b72255a
--- /dev/null
+++ b/clases/02-12 Bindings.ipynb	
@@ -0,0 +1,221 @@
+{
+ "metadata": {
+  "language": "Julia",
+  "name": "",
+  "signature": "sha256:43dfc0e3b2f83ff2f0a77b0b20bc9341311cde5984a16543ef23a34f5bc5a5cf"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "\n",
+      "julia> x = 3\n",
+      "3\n",
+      "\n",
+      "julia> f(x) = x[1]=10\n",
+      "f (generic function with 1 method)\n",
+      "\n",
+      "julia> f(x)\n",
+      "ERROR: `setindex!` has no method matching setindex!(::Int64, ::Int64, ::Int64)\n",
+      " in f at none:1\n",
+      "\n",
+      "julia> x\n",
+      "3\n",
+      "\n",
+      "julia> x\n",
+      "3\n",
+      "\n",
+      "julia> x[1]\n",
+      "3\n",
+      "\n",
+      "julia> \n",
+      "\n",
+      "~ \n",
+      "15:17 $ clear\n",
+      "~ \n",
+      "15:17 $ julia\n",
+      "               _\n",
+      "   _       _ _(_)_     |  A fresh approach to technical computing\n",
+      "  (_)     | (_) (_)    |  Documentation: http://docs.julialang.org\n",
+      "   _ _   _| |_  __ _   |  Type \"help()\" for help.\n",
+      "  | | | | | | |/ _` |  |\n",
+      "  | | |_| | | | (_| |  |  Version 0.3.6-pre+43 (2015-01-22 20:39 UTC)\n",
+      " _/ |\\__'_|_|_|\\__'_|  |  Commit 2dfde6b* (21 days old release-0.3)\n",
+      "|__/                   |  x86_64-apple-darwin14.0.0\n",
+      "\n",
+      "julia> function f(x)\n",
+      "       x = 10\n",
+      "       end\n",
+      "f (generic function with 1 method)\n",
+      "\n",
+      "julia> y = 3\n",
+      "3\n",
+      "\n",
+      "julia> f(y)\n",
+      "10\n",
+      "\n",
+      "julia>  y\n",
+      "3\n",
+      "\n",
+      "julia> function g(x)\n",
+      "       x[1] = 10\n",
+      "       end\n",
+      "g (generic function with 1 method)\n",
+      "\n",
+      "julia> v = [3, 4, 5]\n",
+      "3-element Array{Int64,1}:\n",
+      " 3\n",
+      " 4\n",
+      " 5\n",
+      "\n",
+      "julia> g(v)\n",
+      "10\n",
+      "\n",
+      "julia> v\n",
+      "3-element Array{Int64,1}:\n",
+      " 10\n",
+      "  4\n",
+      "  5\n",
+      "\n",
+      "julia> function h(x)\n",
+      "       x = [3, 4, 5]\n",
+      "       end\n",
+      "h (generic function with 1 method)\n",
+      "\n",
+      "julia> h(v)\n",
+      "3-element Array{Int64,1}:\n",
+      " 3\n",
+      " 4\n",
+      " 5\n",
+      "\n",
+      "julia> v\n",
+      "3-element Array{Int64,1}:\n",
+      " 10\n",
+      "  4\n",
+      "  5\n",
+      "\n",
+      "julia> ^C\n",
+      "\n",
+      "julia> \n",
+      "\n",
+      "julia> f(x)\n",
+      "ERROR: x not defined\n",
+      "\n",
+      "julia> function f(x)\n",
+      "       global hola\n",
+      "       hola = 100\n",
+      "       end\n",
+      "f (generic function with 1 method)\n",
+      "\n",
+      "julia> hola =3 \n",
+      "3\n",
+      "\n",
+      "julia> f(10)\n",
+      "100\n",
+      "\n",
+      "julia> hola\n",
+      "100\n",
+      "\n",
+      "julia> f(x::Int) = 3x\n",
+      "f (generic function with 2 methods)\n",
+      "\n",
+      "julia> duplicar(x::Int) = 2x\n",
+      "duplicar (generic function with 1 method)\n",
+      "\n",
+      "julia> duplicar(2)\n",
+      "4\n",
+      "\n",
+      "julia> duplicar(2.5)\n",
+      "ERROR: `duplicar` has no method matching duplicar(::Float64)\n",
+      "\n",
+      "julia> duplicar(x) = 2x\n",
+      "duplicar (generic function with 2 methods)\n",
+      "\n",
+      "julia> duplicar(2.5)\n",
+      "5.0\n",
+      "\n",
+      "julia> duplicar(2+im)\n",
+      "4 + 2im\n",
+      "\n",
+      "julia> abs(-3)\n",
+      "3\n",
+      "\n",
+      "julia> abs(-3.5)\n",
+      "3.5\n",
+      "\n",
+      "julia> abs(1+2im)\n",
+      "2.23606797749979\n",
+      "\n",
+      "julia> sqrt(5)\n",
+      "2.23606797749979\n",
+      "\n",
+      "julia> methods(abs)\n",
+      "# 19 methods for generic function \"abs\":\n",
+      "abs(x::Bool) at bool.jl:28\n",
+      "abs(x::Unsigned) at int.jl:74\n",
+      "abs(x::Signed) at int.jl:75\n",
+      "abs(x::Float64) at float.jl:207\n",
+      "abs(x::Float32) at float.jl:208\n",
+      "abs(x::Float16) at float16.jl:130\n",
+      "abs(x::Real) at number.jl:24\n",
+      "abs(z::Complex{T<:Real}) at complex.jl:103\n",
+      "abs(B::BitArray{N}) at bitarray.jl:783\n",
+      "abs(A::SparseMatrixCSC{Tv,Ti<:Integer}) at sparse/sparsematrix.jl:481\n",
+      "abs(f::Array{FieldValue,1}) at pkg/resolve/fieldvalue.jl:62\n",
+      "abs{T<:Number}(::AbstractArray{T<:Number,1}) at operators.jl:359\n",
+      "abs{T<:Number}(::AbstractArray{T<:Number,2}) at operators.jl:360\n",
+      "abs{T<:Number}(::AbstractArray{T<:Number,N}) at operators.jl:362\n",
+      "abs{T}(a::HierarchicalValue{T}) at pkg/resolve/versionweight.jl:66\n",
+      "abs(a::VWPreBuildItem) at pkg/resolve/versionweight.jl:94\n",
+      "abs(a::VWPreBuild) at pkg/resolve/versionweight.jl:131\n",
+      "abs(a::VersionWeight) at pkg/resolve/versionweight.jl:185\n",
+      "abs(a::FieldValue) at pkg/resolve/fieldvalue.jl:61\n",
+      "\n",
+      "julia> duplicar(\"s\")\n",
+      "ERROR: `*` has no method matching *(::Int64, ::ASCIIString)\n",
+      " in duplicar at none:1\n",
+      "\n",
+      "julia> duplicar(s::String) == string(s, s)\n",
+      "ERROR: s not defined\n",
+      "\n",
+      "julia> duplicar(s::String) = string(s, s)\n",
+      "duplicar (generic function with 3 methods)\n",
+      "\n",
+      "julia> duplicar(\"Hola\")\n",
+      "\"HolaHola\"\n",
+      "\n",
+      "julia> duplicar(s::String) = s*s\n",
+      "duplicar (generic function with 3 methods)\n",
+      "\n",
+      "julia> duplicar(\"Hola\")\n",
+      "\"HolaHola\"\n",
+      "\n",
+      "julia> s = \"David\"\n",
+      "\"David\"\n",
+      "\n",
+      "julia> s + s\n",
+      "ERROR: `+` has no method matching +(::ASCIIString, ::ASCIIString)\n",
+      "\n",
+      "julia> +(s1::String, s2::String) = s1*s2\n",
+      "+ (generic function with 118 methods)\n",
+      "\n",
+      "julia> s + s\n",
+      "\"DavidDavid\"\n",
+      "\n",
+      "julia> s1::String + s2::String = s1*s2\n",
+      "+ (generic function with 118 methods)\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": []
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/notas/.ipynb_checkpoints/3. Caminantes aleatorios-checkpoint.ipynb b/notas/.ipynb_checkpoints/3. Caminantes aleatorios-checkpoint.ipynb
new file mode 100644
index 0000000..930ce33
--- /dev/null
+++ b/notas/.ipynb_checkpoints/3. Caminantes aleatorios-checkpoint.ipynb	
@@ -0,0 +1,166 @@
+{
+ "metadata": {
+  "language": "Julia",
+  "name": "",
+  "signature": "sha256:e9fd622367787fa36ea3d687008efe5a77da8195ae231b766a4ca5077e699b19"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Caminatas aleatorias"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Uno de los procesos estoc\u00e1sticos m\u00e1s fundamentales e importantes en la f\u00edsica es el *movimiento Browniano*. Un acercamiento inicial a este p|roblema se da a trav\u00e9s de las *caminatas aleatorias*, que modela una part\u00edcula que recibe impactos al azar, que hacen que brinque en direcciones aleatorias."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[1] Piensa en una caminata aleatoria en una dimensi\u00f3n. Vive en los enteros, y en cada paso de tiempo brinca a la derecha con probabilidad $\\frac{1}{2}$ y a la izquierda con probabilidad $\\frac{1}{2}$.\n",
+      "\n",
+      "Escribe una funci\u00f3n que genere el tama\u00f1o del brinco: $+1$ o $-1$, cada uno con probabilidad $\\frac{1}{2}$."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "function tamano_brinco(t)\n",
+      "    brinco = 0\n",
+      "    for i in 1:t\n",
+      "        if rand()>0.5\n",
+      "            brinco+=1\n",
+      "        else\n",
+      "            brinco-=1\n",
+      "        end\n",
+      "    end\n",
+      "    return brinco\n",
+      "end\n",
+      "\n",
+      "tamano_brinco(500)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 6,
+       "text": [
+        "8"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[2] Haz una funci\u00f3n que calcule la trayectoria de una caminata aleatoria que empiece en $0$ y toma $n$ pasos al azar. Regresa la trayectoria.\n",
+      "\n",
+      "(a) Dibuja varias trayectorias en una misma gr\u00e1fica, como funci\u00f3n del tiempo. \u00bfQu\u00e9 observas?\n",
+      "\n",
+      "(b) Dibuja *muchas* trayectorias en una misma gr\u00e1fica. \u00bfQu\u00e9 observas?\n",
+      "\n",
+      "(c) Dibuja distintas curvas encima para intentar adivinar c\u00f3mo se comporta la mancha en el tiempo.\n",
+      "\n",
+      "(d) En lugar de dibujar muchas curvas, s\u00f3lo dibuja los l\u00edmites inferiores y superiores de la mancha. \u00bfC\u00f3mo cambian en el tiempo? Dib\u00fajalos de otra forma para verificar esto."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [],
+     "language": "python",
+     "metadata": {},
+     "outputs": []
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "function trayectoria(n)\n",
+      "    x=zeros(n)\n",
+      "    for i 1:n\n",
+      "        if i==0\n",
+      "            x[i] = rand()>0.5 ? 1 : -1\n",
+      "        else\n",
+      "            x[i] = rand()>0.5 ?  x[i]+1: x[i]-1\n",
+      "        end\n",
+      "    end\n",
+      "    return x\n",
+      "end\n",
+      "\n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": []
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "a = true ? 1 :0"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 7,
+       "text": [
+        "1"
+       ]
+      }
+     ],
+     "prompt_number": 7
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[3] Modifica tu funci\u00f3n para que brinque a la derecha con probabilidad $p$ y a la izquierda con probabilidad $q := 1-p$. Para varios valores de $p$, dibuja varias trayectorias en una sola gr\u00e1fica (una gr\u00e1fica por valor de $p$). \u00bfQu\u00e9 observas? \n",
+      "\n",
+      "[Puedes crear nuevas figuras en `PyPlot` con `figura()`.]"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[4] Piensa en un tiempo final $n$ dado. \u00bfC\u00f3mo puedes caracterizar a la colecci\u00f3n de posiciones de la colecci\u00f3n de las posiciones de un n\u00famero grande $M$ de caminantes aleatorios en este tiempo? Dibuja varias caracterizaciones como funci\u00f3n del tiempo final $n$."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[5] Modifica tu caminante para que tenga una probabilidad $r$ de quedarse en el mismo lugar. \u00bfC\u00f3mo cambian los resultados?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[6] Haz lo mismo para caminantes en 2D y caminantes en 3D. [Aqu\u00ed ya no dibujes las trayectorias como funci\u00f3n del tiempo, sino dibuja las trayectorias en el espacio.]"
+     ]
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/notas/1. Numeros aleatorios y probabilidad.ipynb b/notas/1. Numeros aleatorios y probabilidad.ipynb
new file mode 100644
index 0000000..c0a688c
--- /dev/null
+++ b/notas/1. Numeros aleatorios y probabilidad.ipynb	
@@ -0,0 +1,243 @@
+{
+ "metadata": {
+  "language": "Julia",
+  "name": "",
+  "signature": "sha256:0de8fa8d27bed9097013da87f85bf7bdef95ec71dd387038cfadc76e4768ff79"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "El generador de n\u00fameros aleatorios"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Julia incluye un *generador de n\u00fameros (seudo-)aleatorios* (RNG, \"Random Number Generator\"). Cada vez que llamamos a la funci\u00f3n `rand()`, regresa un n\u00famero aleatorio distinto. El generador de Julia es (actualmente) uno llamado *Mersenne Twister*. Utiliza ideas complejas de teor\u00eda de n\u00fameros para asegurarse que los n\u00fameros aleatorios son \"suficientemente aleatorios\"."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[1] Teclea \n",
+      "\n",
+      "    rand()\n",
+      "    \n",
+      "en el REPL o en IJulia (por ejemplo, en [JuliaBox](http://juliabox.org)). En IJulia, utiliza `Shift-Enter` para ejecutar el comando y crear una nueva celda, o `Ctrl-Enter` para ejecutar el comando y quedarse en la misma celda.\n",
+      "\n",
+      "Hazlo varias veces. \u00bfQu\u00e9 tipo de n\u00fameros regresa? Utiliza la funci\u00f3n `typeof` para verificar tu respuesta. El \u00faltimo valor se obtiene con `ans`. \u00bfEntre d\u00f3nde y d\u00f3nde est\u00e1n acotados los n\u00fameros?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[2] \u00bfQu\u00e9 pasa si tecleas `rand` sin las par\u00e9ntesis?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[3] Utiliza `?rand` para obtener ayuda sobre la funci\u00f3n."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[4] \u00bfC\u00f3mo se pueden generar varios n\u00fameros aleatorios a la vez, usando `rand`? \u00bfY una matriz aleatoria? \u00bfQu\u00e9 tipos tienen las respuestas obtenidas?"
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Graficar"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Hay varios paquetes disponibles para graficar en Julia. Comenzaremos con uno llamado `PyPlot`, que es un interfaz de Julia a la librer\u00eda `matplotlib` de Python. Para asegurarte de tener instalado el paquete en tu sistema, haz\n",
+      "\n",
+      "    Pkg.add(\"PyPlot\")\n",
+      "    \n",
+      "Necesitas estar conectado a internet. Esto se hace una sola vez para cada instalaci\u00f3n de Julia.\n",
+      "\n",
+      "Luego en cada notebook, utiliza\n",
+      "\n",
+      "    using PyPlot\n",
+      "    \n",
+      "para hacer disponible la funcionalidad del paquete."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[5] Genera un n\u00famero grande de n\u00fameros aleatorios usando `rand`. Asigna la respuesta obtenida a una variable `x`.\n",
+      "Usa `plot(x)` para dibujar los resultados. Puedes agregar una opci\u00f3n `\"o\"` a la funci\u00f3n `plot` para dibujar con puntos."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[6] Define una variable entera `N`. Genera dos colecciones de n\u00fameros aleatorios `x` y `y`, las dos de longitud `N`. Dibuja los pares $(x,y)$ con\n",
+      "\n",
+      "    plot(x, y)\n",
+      "    \n",
+      "con puntos. Utiliza\n",
+      "\n",
+      "    axis(\"equal\")\n",
+      "    \n",
+      "para que la raz\u00f3n de aspecto se vea mejor. \n",
+      "\n",
+      "\u00bfQu\u00e9 observas? \u00bfQu\u00e9 tipo de distribuci\u00f3n tienen los n\u00fameros aleatorios?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[7] Genera una colecci\u00f3n de n\u00fameros aleatorios `x`. Genera otra colecci\u00f3n `y` con el mismo tama\u00f1o que `x` pero con puros ceros, usando la funci\u00f3n `zeros`. Dibuja el resultado para ver c\u00f3mo se distribuyen los n\u00fameros aleatorios en una sola dimensi\u00f3n."
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "Usando los n\u00fameros aleatorios: caminatas aleatorias"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "\u00bfPara qu\u00e9 utilizamos los n\u00fameros aleatorios? A menudo, es para llevar a cabo una operaci\u00f3n *con cierta probabilidad*."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[8] Pensando en c\u00f3mo se distribuyen los n\u00fameros aleatorios, \u00bfc\u00f3mo se puede llevar a cabo una operaci\u00f3n con probabilidad 0.5? \u00bfCon probabilidad $p$ tal que $0 < p < 1$?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[9] Define una funci\u00f3n que genera un paso de una *caminata aleatoria*, que toma pasos a la izquierda con probabilidad 0.5 y a la derecha con probabilidad 0.5. La funci\u00f3n regresa el paso escogido."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[10] Generaliza tu funci\u00f3n para aceptar un argumento `p` que corresponde a la probabilidad $p$ de brincar a la derecha, y $1-p$ a la izquierda."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "[11] Haz una funci\u00f3n que genera una trayectoria de una caminata aleatoria con $N$ pasos y probabilidad $p$."
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "function f(p,n)\n",
+      "    x=[0.0]\n",
+      "    for i in 2:n\n",
+      "        if rand()<=p\n",
+      "            push!(x,x[i-1]+0.5)\n",
+      "        else\n",
+      "            push!(x,x[i-1]-0.5)\n",
+      "        end\n",
+      "    end\n",
+      "    return x\n",
+      "end"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 1,
+       "text": [
+        "f (generic function with 1 method)"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "using PyPlot"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "plot(f(0.5,100))"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "display_data",
+       "png": "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",
+       "text": [
+        "PyPlot.Figure(PyObject <matplotlib.figure.Figure object at 0xe6c4550>)"
+       ]
+      },
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 4,
+       "text": [
+        "1-element Array{Any,1}:\n",
+        " PyObject <matplotlib.lines.Line2D object at 0x54b27d0>"
+       ]
+      }
+     ],
+     "prompt_number": 4
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [],
+     "language": "python",
+     "metadata": {},
+     "outputs": []
+    }
+   ],
+   "metadata": {}
+  }
+ ]
+}
\ No newline at end of file
diff --git a/notas/2 b/notas/2
new file mode 100644
index 0000000..ff349b5
--- /dev/null
+++ b/notas/2
@@ -0,0 +1,537 @@
+{
+ "metadata": {
+  "kernelspec": {
+   "codemirror_mode": "julia",
+   "display_name": "Julia",
+   "language": "julia",
+   "name": "julia"
+  },
+  "language": "Julia",
+  "name": "",
+  "signature": "sha256:da4136dd77a3eaa3b79e175afe018820ca5586edbafbad78697f8ee78379b638"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "heading",
+     "level": 1,
+     "metadata": {},
+     "source": [
+      "\u00bfQu\u00e9 es una distribuci\u00f3n de probabilidad?"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "[1:6],[1:6]"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 9,
+       "text": [
+        "([1,2,3,4,5,6],[1,2,3,4,5,6])"
+       ]
+      }
+     ],
+     "prompt_number": 9
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "El concepto de *distribuci\u00f3n de probabilidad* es fundamental. Describe c\u00f3mo se reparte la probabilidad de una *variable aleatoria*. \n",
+      "\n",
+      "Le damos el nombre *variable aleatoria* a una cantidad que toma distintos valores cada vez que lo medimos. (El nombre no es bueno.) Ciertos valores pueden ser *m\u00e1s probables* y otros menos probables."
+     ]
+    },
+    {
+     "cell_type": "heading",
+     "level": 2,
+     "metadata": {},
+     "source": [
+      "Lanzar un dado"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Como primer ejemplo, pensemos en un dado. Cuando lanzamos un dado, puede caer en uno de los lados $1$ a $6$. Si el dado no tiene sesgo, esperamos que caer\u00e1 con \"igual probabilidad\" $\\frac{1}{6}$ en cada lado. Pero, \u00bfqu\u00e9 queremos decir con esta aseveraci\u00f3n?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "En una interpretaci\u00f3n \"frecuentista\" de la probabilidad, nos referimos a que si lanzamos el dado un n\u00famero muy grande $N$ de veces, caer\u00e1 en cada lado $N/6$ veces. [Otra interpretaci\u00f3n, m\u00e1s favorecida hoy d\u00eda, es la Bayesiana.]"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "La colecci\u00f3n de todas las probabilidades de todos los valores posibles de la variable aleatoria $X$, \"el valor que arroja el dado\", se llama la *distribuci\u00f3n de probabilidad* de $X$.  Escribimos $P(X=1) = \\frac{1}{6}$, etc."
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "Si las probabilidades son iguales, decimos que la distribuci\u00f3n es *uniforme*. Pero si realmente hacemos el experimento, \u00bfqu\u00e9 tan uniformes salen las frecuencias?"
+     ]
+    },
+    {
+     "cell_type": "markdown",
+     "metadata": {},
+     "source": [
+      "**Ejercicio 1**:\n",
+      "\n",
+      "(a) Genera un n\u00famero aleatorio uniforme entero entre 1 y 6 con\n",
+      "\n",
+      "    rand(1:6)\n",
+      "    \n",
+      "[Checa cu\u00e1l es el tipo del objeto `1:6`.] \n",
+      "\n",
+      "(b) \u00bfC\u00f3mo se pueden generar $N$ tales n\u00fameros? Haz una funci\u00f3n para hacerlo.\n",
+      "\n",
+      "(c) Cuenta el n\u00famero de veces que dio $1$, $2$, $\\ldots$, $6$ y as\u00ed calcula las frecuencias al normalizarlos con el n\u00famero total.\n",
+      "\n",
+      "(d) Dibuja el resultado. \u00bfQu\u00e9 observas? Hazlo varias veces con el mismo valor de $N$.\n",
+      "\n",
+      "(e) Repite el c\u00e1lculo con n\u00fameros $N$ mayores. \u00bfQu\u00e9 observas?\n",
+      "\n",
+      "(f) Calcula para cada $N$ cu\u00e1nto *desv\u00eda* el valor observado del valor te\u00f3rico esperado. Dibuja esto en funci\u00f3n de $N$. \u00bfC\u00f3mo se comporta esta desviaci\u00f3n?"
+     ]
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "a=rand(1:6)\n",
+      "typeof(a)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 1,
+       "text": [
+        "Int64"
+       ]
+      }
+     ],
+     "prompt_number": 1
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "n=30000\n",
+      "x=rand(1:6,n);"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [],
+     "prompt_number": 2
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "y=zeros(6)\n",
+      "for i in x\n",
+      "    for j in 1:6\n",
+      "        if i==j\n",
+      "            y[j]+=1\n",
+      "        end\n",
+      "    end\n",
+      "end\n",
+      "y/n"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "pyout",
+       "prompt_number": 3,
+       "text": [
+        "6-element Array{Float64,1}:\n",
+        " 0.165333\n",
+        " 0.166   \n",
+        " 0.165467\n",
+        " 0.166767\n",
+        " 0.1654  \n",
+        " 0.171033"
+       ]
+      }
+     ],
+     "prompt_number": 3
+    },
+    {
+     "cell_type": "code",
+     "collapsed": true,
+     "input": [
+      "using PyPlot"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stderr",
+       "text": [
+        "INFO: Loading help data...\n"
+       ]
+      }
+     ],
+     "prompt_number": 27
+    },
+    {
+     "cell_type": "code",
+     "collapsed": true,
+     "input": [
+      "function dados(n,caras,exps)\n",
+      "    ys=Array[[0]]\n",
+      "    for i in 1:exps\n",
+      "        x=rand(1:caras,n)\n",
+      "        y=zeros(caras)\n",
+      "        for j in x\n",
+      "            for k in 1:caras\n",
+      "                if j==k\n",
+      "                    y[k]+=1\n",
+      "                end\n",
+      "            end\n",
+      "        end\n",
+      "        println(y/n)\n",
+      "        ys[i]=y/n\n",
+      "        println(ys)\n",
+      "    end\n",
+      "    return ys\n",
+      "end\n",
+      "dados(100,6,10)"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "output_type": "stream",
+       "stream": "stdout",
+       "text": [
+        "[0.14,0.09,0.13,0.18,0.27,0.19]\n",
+        "Array[[0.14,0.09,0.13,0.18,0.27,0.19]]\n",
+        "[0.14,0.16,0.23,0.1,0.18,0.19]\n"
+       ]
+      },
+      {
+       "ename": "LoadError",
+       "evalue": "BoundsError()\nwhile loading In[6], in expression starting on line 19",
+       "output_type": "pyerr",
+       "traceback": [
+        "BoundsError()\nwhile loading In[6], in expression starting on line 19",
+        "",
+        " in dados at In[6]:14"
+       ]
+      }
+     ],
+     "prompt_number": 6
+    },
+    {
+     "cell_type": "code",
+     "collapsed": false,
+     "input": [
+      "function dados(n,caras)    \n",
+      "    x=rand(1:caras,n)\n",
+      "    y=zeros(caras)\n",
+      "    for j in x\n",
+      "        for k in 1:caras\n",
+      "            if j==k\n",
+      "                y[k]+=1\n",
+      "            end\n",
+      "        end\n",
+      "    end\n",
+      "    return y/n\n",
+      "end\n",
+      "\n",
+      "exps=10\n",
+      "caras=6\n",
+      "n=1000000\n",
+      "for i in 1:exps\n",
+      "    plot(1:caras,dados(n,caras))\n",
+      "end"
+     ],
+     "language": "python",
+     "metadata": {},
+     "outputs": [
+      {
+       "metadata": {},
+       "output_type": "display_data",
+       "png": "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