{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducción a la Programación en MATLAB (C4)\n",
    "\n",
    "Mauricio Tejada\n",
    "\n",
    "ILADES - Universidad Alberto Hurtado\n",
    "\n",
    "Agosto 2017\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Contenidos\n",
    "\n",
    "- [Funciones de Matlab](#4.-Funciones-de-Matlab)\n",
    "    - [Funciones Escalares](#4.1-Funciones-Escalares)\n",
    "    - [Funciones Vectoriales](#4.2-Funciones-Vectoriales)\n",
    "    - [Funciones Matriciales](#4.3-Funciones-Matriciales)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## 4. Funciones de Matlab\n",
    "\n",
    "Matlab provee muchas funciones para realizar operaciones matemáticas y analizar datos. Categorizamos dichas funciones en matriciales, vectoriales y escalares. \n",
    "\n",
    "Aquí presentamos sólo algunos ejemplos de las funciones que les serán más útiles. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Funciones Escalares\n",
    "\n",
    "Las funciones escalares aplican operaciones sobre *escalares*. Son utilizables en matrices, vectores y escalares. En el caso de los dos primeros, la operaciones se realizan elemento por elemento.\n",
    "\n",
    "Algunos ejemplos:\n",
    "\n",
    "- `sin`, `cos`: Seno, Coseno\n",
    "- `exp`, `log`, `log10`, `abs`: Exponencial, logaritmo natural, logaritmo base 10 Valor absoluto\n",
    "- `sign`: Signo (1 para positivo, -1 para negativo) \n",
    "- `round`, `ceil`, `floor`: Redondea a entero\n",
    "\n",
    "Ver `help elfun` para un listado completo de las funciones elementales de Matlab."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a =\n",
      "\n",
      "     2\n",
      "\n",
      "\n",
      "expa =\n",
      "\n",
      "    7.3891\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "expa = exp(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "B =\n",
      "\n",
      "     2\n",
      "     3\n",
      "\n",
      "\n",
      "expB =\n",
      "\n",
      "    7.3891\n",
      "   20.0855\n"
     ]
    }
   ],
   "source": [
    "B = [2; 3]\n",
    "expB = exp(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "C =\n",
      "\n",
      "    0.8147    0.1270\n",
      "    0.9058    0.9134\n",
      "\n",
      "\n",
      "logC =\n",
      "\n",
      "   -0.2049   -2.0637\n",
      "   -0.0989   -0.0906\n"
     ]
    }
   ],
   "source": [
    "C = rand(2,2)\n",
    "logC = log(C)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Funciones Vectoriales\n",
    "\n",
    "Las funciones vectoriales aplican operaciones sobre *vectores*. Son utilizables en matrices y vectores. En el caso de las primeras, las operaciones se aplican por fila o por columna (por defecto por columna)\n",
    "\n",
    "Algunos ejemplos:\n",
    "\n",
    "- `max`, `min`: Máximo, mínimo por columnas\n",
    "- `sort`, `sortrows`: Ordenar vector, ordenar filas de una matriz\n",
    "- `sum`, `prod`, `cumsum`, `cumprod`: Suma, producto, suma acumulada, producto acumulado\n",
    "- `mean`, `std`, `median`, `var`, `cov`: Media, desviación estándar, mediana, varianza, covarianza\n",
    "- `length`: Tamaño de un vector\n",
    "\n",
    "Nota: Las funciones vectoriales, según la operación que realicen tienen diversas opciones y posiblemente más de un *output*. Ver opciones de cada función usando `help funcion`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v =\n",
      "\n",
      "    1.0000\n",
      "    1.5000\n",
      "    2.0000\n",
      "    2.5000\n",
      "    3.0000\n",
      "    3.5000\n",
      "    4.0000\n",
      "\n",
      "\n",
      "vm =\n",
      "\n",
      "     4\n"
     ]
    }
   ],
   "source": [
    "v = (1:0.5:4)'\n",
    "vm = max(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ejemplo de uso de funciones con más de un argumento de la función:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "G =\n",
      "\n",
      "    0.6324    0.9649    0.8003\n",
      "    0.0975    0.1576    0.1419\n",
      "    0.2785    0.9706    0.4218\n",
      "    0.5469    0.9572    0.9157\n",
      "    0.9575    0.4854    0.7922\n"
     ]
    }
   ],
   "source": [
    "G = rand(5,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mGc =\n",
      "\n",
      "    0.5026    0.7071    0.6144\n",
      "\n",
      "\n",
      "mGf =\n",
      "\n",
      "    0.7992\n",
      "    0.1323\n",
      "    0.5570\n",
      "    0.8066\n",
      "    0.7450\n"
     ]
    }
   ],
   "source": [
    "mGc = mean(G,1)\n",
    "mGf = mean(G,2) % Usamos el segundo argumento para cambiar orientación."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Ejemplo de una función con más de un *output*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R =\n",
      "\n",
      "    0.9595    0.8491\n",
      "    0.6557    0.9340\n",
      "    0.0357    0.6787\n",
      "\n",
      "\n",
      "vmax =\n",
      "\n",
      "    0.9595    0.9340\n",
      "\n",
      "\n",
      "pos =\n",
      "\n",
      "     1     2\n"
     ]
    }
   ],
   "source": [
    "R=rand(3,2)\n",
    "[vmax, pos] = max(R)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =\n",
      "\n",
      "     1     3     6\n"
     ]
    }
   ],
   "source": [
    "x = [1 2 3];\n",
    "cumsum(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Es siempre útil conocer el tamaño de un vector."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "v =\n",
      "\n",
      "    0.7577    0.7431    0.3922    0.6555    0.1712    0.7060\n",
      "\n",
      "\n",
      "lv =\n",
      "\n",
      "     6\n"
     ]
    }
   ],
   "source": [
    "v=rand(1,6)\n",
    "lv = length(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.3 Funciones Matriciales\n",
    "\n",
    "La funciones matriciales realizan operaciones sobre *matrices* y sólo son utilizables con este tipo de objetos. \n",
    "\n",
    "Algunos ejemplos:\n",
    "\n",
    "- `size`: Tamaño de la matriz.\n",
    "- `inv`: Inversa (es mejor utilizar `/`).\n",
    "- `eig`: Autovalores y autovectores.\n",
    "- `chol`: Descomposición de Cholesky\n",
    "- `det`: Determinante.\n",
    "- `kron`: Producto de kronecker.\n",
    "- `:` Convierte un matriz en un vector columna: vectorizar `A(:)`.\n",
    "- `reshape(A,filas,columnas)`: Cambio de dimensión.\n",
    "- `diag`: Diagonal de una matriz (además matriz diagonal si el argumento es un vector).\n",
    "- `triu`, `tril`: Matrices triangulares, superior e inferior.\n",
    "\n",
    "Ejemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "\n",
      "    0.0318    0.8235\n",
      "    0.2769    0.6948\n",
      "    0.0462    0.3171\n",
      "    0.0971    0.9502\n",
      "\n",
      "\n",
      "I =\n",
      "\n",
      "     4\n",
      "\n",
      "\n",
      "J =\n",
      "\n",
      "     2\n"
     ]
    }
   ],
   "source": [
    "A = rand(4,2)\n",
    "[I, J] = size(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A =\n",
      "\n",
      "    6.5770   10.6384    9.9399\n",
      "    9.7955   10.6257    9.6702\n",
      "    9.5171    8.2702   11.2554\n",
      "\n",
      "\n",
      "AVec =\n",
      "\n",
      "    0.5475    0.8524   -0.1985\n",
      "    0.6029   -0.3642   -0.6219\n",
      "    0.5803   -0.3752    0.7575\n",
      "\n",
      "\n",
      "AVal =\n",
      "\n",
      "   28.8277         0         0\n",
      "         0   -2.3421         0\n",
      "         0         0    1.9725\n"
     ]
    }
   ],
   "source": [
    "A = 10+2*randn(3,3)\n",
    "[AVec, AVal] = eig(A) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F =\n",
      "\n",
      "    0.7094    0.6797    0.1190    0.3404\n",
      "    0.7547    0.6551    0.4984    0.5853\n",
      "    0.2760    0.1626    0.9597    0.2238\n",
      "\n",
      "\n",
      "daigF =\n",
      "\n",
      "    0.7094\n",
      "    0.6551\n",
      "    0.9597\n"
     ]
    }
   ],
   "source": [
    "F = rand(3,4)\n",
    "daigF = diag(F)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "newF =\n",
      "\n",
      "    0.7094    0.2760    0.6551    0.1190    0.9597    0.5853\n",
      "    0.7547    0.6797    0.1626    0.4984    0.3404    0.2238\n"
     ]
    }
   ],
   "source": [
    "newF = reshape(F,2,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ans =\n",
      "\n",
      "    0.7094\n",
      "    0.7547\n",
      "    0.2760\n",
      "    0.6797\n",
      "    0.6551\n",
      "    0.1626\n",
      "    0.1190\n",
      "    0.4984\n",
      "    0.9597\n",
      "    0.3404\n",
      "    0.5853\n",
      "    0.2238\n"
     ]
    }
   ],
   "source": [
    "F(:)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Matlab",
   "language": "matlab",
   "name": "matlab"
  },
  "language_info": {
   "file_extension": ".m",
   "help_links": [
    {
     "text": "MetaKernel Magics",
     "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md"
    }
   ],
   "mimetype": "text/x-octave",
   "name": "matlab",
   "version": "0.9.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}