1.6-intro-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Funciones\n",
    "\n",
    "Topicos:\n",
    "1. Como declarar una función\n",
    "2. Duck-typing en Julia\n",
    "3. Mutating vs. non-mutating functions\n",
    "4. Algunas funciones de mayor órden"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Como declarar una función\n",
    "\n",
    "Julia tiene varias formas de escribir una función. La primera requiere de los comandos `function` y `end`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function saluda(nombre)\n",
    "    println(\"Hola $nombre, que lindo verte!\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "function f(x)\n",
    "    x^2\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos aplicar cualquiera de estas dos funciones así:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saluda(\"Juana\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternativamente, podríamos haber definido las funciones en una única línea:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saluda2(nombre) = println(\"Hola $nombre, que lindo verte!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2(x) = x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saluda2(\"Juan\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f2(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por último, podríamos haberlas declarado como funciones \"anónimas\" (más abajo veremos para que sirven)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saluda3 = name -> println(\"Hola $name, que lindo verte!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f3 = x -> x^2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saluda3(\"José\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f3(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Las funciones toman cualquier input que tenga sentido\n",
    "\n",
    "Las funciones de Julia funcionan sobre cualquier input que tenga sentido.\n",
    "\n",
    "`saluda` puede saludar a un número:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "saluda(55595472)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Y `f` funciona con matrices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = rand(3, 3)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`f` también funciona con una string como \"hola\" porque `*` está definido para strings como concatenación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(\"hola\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por otro lado, `f` no funciona sobre vectores. A diferencia de `A^2`, que está bien definido, el significado de `v^2` para un vector `v` no es una operación algebráica bien definida."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = rand(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# This won't work\n",
    "f(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones que modifican sus inputs\n",
    "\n",
    "Por convención, las funciones que terminan con `!` pueden modificar el contenido de sus inputs, y las funciones que no tienen `!` no lo hacen.\n",
    "\n",
    "Por ejemplo, veamos la diferencia entre `sort` y `sort!`.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = [3, 5, 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sort(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`sort(v)` devuelve un arreglo ordenado que contiene los mismos elementos que `v`, pero `v` no se modifica.\n",
    "\n",
    "Por otro lado, cuando corremos `sort!(v)`, los contenidos de `v` son ordenados **modificando** `v`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sort!(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Algunas funciones de mayor orden\n",
    "\n",
    "#### `map`\n",
    "\n",
    "`map` es una función de \"mayor orden\" en Julia que toma una *función* como uno de sus inputs.\n",
    "\n",
    "`map` luego aplica esa función a cada elemento de la estructura de datos que le pasamos como segundo argumento. Por ejemplo, correr:\n",
    "\n",
    "```julia\n",
    "map(f, [1, 2, 3])\n",
    "```\n",
    "\n",
    "va a resultar en un arreglo donde la función `f` se aplicó a todos los elementos de `[1, 2, 3]`\n",
    "\n",
    "```julia\n",
    "[f(1), f(2), f(3)]\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map(f, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Elevamos al cuadrado todos los elementos del vector `[1, 2, 3]`, en lugar de elevar el vector `[1, 2, 3]` al cuadrado.\n",
    "\n",
    "Podríamos haber hecho lo mismo con una función anónima, en lugar de una función con nombre como `f`. \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x -> x^3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por ejemplo, podemos elevar los elementos de `[1, 2, 3]` al cubo de la siguiente forma:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "map(x -> x^3, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `broadcast`\n",
    "\n",
    "`broadcast` es una generalización de `map`. Puede hacer lo mismo que `map` y más (ahora veremos qué). La sintaxis es igual a `map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broadcast(f, [1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "nuevamente, aplicamos `f` a todos los elementos de `[1, 2, 3]` - esta vez *broadcasting* `f`.\n",
    "\n",
    "Otra forma de llamar la función `broadcast` es poniendo un `.` entre el nombre de la función que queremos `broadcast`ear  y sus inputs. Por ejemplo,\n",
    "\n",
    "```julia\n",
    "broadcast(f, [1, 2, 3])\n",
    "```\n",
    "\n",
    "es lo mismo que\n",
    "\n",
    "```julia\n",
    "f.([1, 2, 3])\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f.([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notar nuevamente lo distinto que es esto a correr \n",
    "\n",
    "```julia\n",
    "f([1, 2, 3])\n",
    "```\n",
    "\n",
    "Podemos elevar al cuadrado cada elemento de un vector, pero no podemos elevar un vector al cuadrado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para fijar ideas, veamos la diferencia entre:\n",
    "\n",
    "```julia\n",
    "f(A)\n",
    "```\n",
    "y\n",
    "```julia\n",
    "f.(A)\n",
    "```\n",
    "para una matriz `A`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = [i + 3*j for j in 0:2, i in 1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como antes, vemos que para una matriz, `A`,\n",
    "\n",
    "```\n",
    "f(A) = A^2 = A * A\n",
    "``` \n",
    "\n",
    "Por otro lado,"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = f.(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "contiene todos los elementos de `A` elevados al cuadrado.\n",
    "\n",
    "Esta \"dot syntax\" para hacer broadcasting nos permite escribir expresiones relativamente complejas de una forma que se lee naturalmente y es más cercana a la notación matemática. Por ejemplo, podemos escribir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A .+ 2 .* f.(A) ./ A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "en lugar de"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "broadcast(x -> x + 2 * f(x) / x, A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "y ambas funcionarán exactamente igual. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ejercicios\n",
    "\n",
    "#### 6.1 \n",
    "\n",
    "Escribir una función `suma_uno` que agregue 1 a su input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "hide_input": true,
    "nbgrader": {
     "checksum": "253b17dc2f3d3a58042fbc36042a0fd5",
     "grade": true,
     "grade_id": "cell-5119b9e9623c1cb7",
     "locked": true,
     "points": 1,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "@assert add_one(1) == 2\n",
    "@assert add_one(11) == 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.2 \n",
    "\n",
    "Usar `map` o `broadcast` para incrementar cada elemento de `A` en `1` y asignar el resultado a la matriz `A1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "@assert A1 == [2 3 4; 5 6 7; 8 9 10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.3 \n",
    "\n",
    "Usar la sintaxis de `broadcast` con `.` para incrementar cada elemento de la matriz `A1` en 1 y guardarlo en la matriz `A2`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "deletable": false,
    "editable": false,
    "hide_input": true,
    "nbgrader": {
     "checksum": "3e3d797962df904deed0e7ee7782b69a",
     "grade": true,
     "grade_id": "cell-f3bd5479679a8fe1",
     "locked": true,
     "points": 0,
     "schema_version": 1,
     "solution": false
    }
   },
   "outputs": [],
   "source": [
    "@assert A2 == [3 4 5; 6 7 8; 9 10 11]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 6.4\n",
    "\n",
    "La operación factorial se define como $n! = 1 × 2 × ... × (n - 1) × n$. Julia tiene su propia función `factorial` interna que calcula esto. \n",
    "\n",
    "Definir una función nueva `factorial2(n)` que tome un input `n` y devuelva el factorial. \n",
    "\n",
    "Tip: Usar un `for` loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.10.4",
   "language": "julia",
   "name": "julia-1.10"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.10.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}