clases/clase_4/402_señales_discretas.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Señales discretas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Índice\n",
    "\n",
    "* [Señales discretas básicas](#Señales-discretas-básicas)\n",
    "    * [Impulso unitario (delta de Kronecker)](#Impulso-unitario-(delta-de-Kronecker))\n",
    "    * [Pulso rectangular](#Pulso-rectangular)\n",
    "    * [Escalón unitario o heaviside discreta](#Escalon-unitario-o-heaviside-discreta)\n",
    "        * [Propiedades de las señales](#Propiedades-de-las-señales)\n",
    "    * [Otras señales de interes](#Otras-señales-de-interes)\n",
    "        * [Rampa](#Rampa)\n",
    "        * [Secuencia exponencial de valores reales](#Secuencia-exponencial-de-valores-reales)\n",
    "        * [Secuencia exponencial de valores complejos](#Secuencia-exponencial-de-valores-complejos)\n",
    "        * [Secuencia senoidal](#Secuencia-senoidal)\n",
    "        * [Secuencia aleatoria](#Secuencia-aleatoria)\n",
    "        * [Funcion Sinc](#Funcion-Sinc)\n",
    "    * [Pulso unitario desplazado y escalado](#Pulso-unitario-desplazado-y-escalado)\n",
    "    * [Escalón unitario desplazado y escalado](#Escalón-unitario-desplazado-y-escalado) \n",
    "* [Tipos de datos](#Tipos-de-datos)\n",
    "* [Longitud y dimensiones de un array](#Longitud-y-dimensiones-de-un-array)\n",
    "* [Indizado en arrays](#Indizado-en-arrays)\n",
    "* [Referencias](#Referencias)\n",
    "* [Licencia](#Licencia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos del notebook\n",
    "\n",
    "* Definir y trabajar con señales básicas.\n",
    "* Conocer sobre tipo de datos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Periodicidad de señales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Impulso unitario (delta de Kronecker)\n",
    "\n",
    "$$\\delta[n]=\\begin{cases} 1, \\text{para } n=0 \\\\  0, \\text{para  } n\\neq 0 \\end{cases}=\\left\\lbrace \\ldotp \\ldotp \\ldotp ,0,0,1^{\\uparrow } ,0,0,\\ldotp \\ldotp \\ldotp \\right\\rbrace$$\n",
    "\n",
    "$$\\delta \\left\\lbrack n-n_0 \\right\\rbrack =\\left\\lbrace \\begin{array}{c}1 & n=n_0 \\\\0 & n\\ne n_0 \\end{array}\\right.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-2-0e0536daf23f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdelta\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mzeros\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# Une una secuencia de matrices a lo largo de un eje existente.\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mn\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m-\u001b[0m\u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m11\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstem\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mdelta\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Impulso unitario'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "delta = np.concatenate((np.zeros(10),np.ones(1),np.zeros(10))) # Une una secuencia de matrices a lo largo de un eje existente.\n",
    "n = np.arange(-10, 11)\n",
    "\n",
    "plt.stem(n,delta)\n",
    "plt.title('Impulso unitario')\n",
    "plt.ylabel('Amplitud $\\delta[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Pulso rectangular\n",
    "\n",
    "$$P[n]=\\begin{cases} 1/\\tau, \\text{para } \\vert n \\vert< \\tau/2  \\\\  0, \\text{resto  } \n",
    "\\end{cases}$$\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/max/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Muestras $n$')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "P = np.concatenate((np.zeros(5),np.ones(11),np.zeros(5)))\n",
    "n = np.arange(-10, 11)\n",
    "\n",
    "plt.stem(n,P)\n",
    "plt.title('Pulso rectangular')\n",
    "plt.ylabel('Amplitud $P[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escalon unitario o heaviside discreta\n",
    "\n",
    "$$u[n]=\\begin{cases} 0, \\text{para } n<0  \\\\  1, \\text{para  } n\\geq 0 \\end{cases}$$\n",
    "\n",
    "$$u\\left\\lbrack n-n_0 \\right\\rbrack =\\left\\lbrace \\begin{array}{c}\n",
    "1 & n\\ge n_0 \\\\0 & n<n_0 \\end{array}\\right.$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u = np.concatenate((np.zeros(10),np.ones(11)))\n",
    "n = np.arange(-10, 11)\n",
    "\n",
    "plt.stem(n,u)\n",
    "plt.title('Escalón unitario')\n",
    "plt.ylabel('Amplitud $u[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Propiedades de las señales"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\delta[n]=u[n]-u[n-1]$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u1 = np.concatenate((np.zeros(10),np.ones(11)))\n",
    "u2 = np.concatenate((np.zeros(11),np.ones(10)))\n",
    "\n",
    "delta = u1-u2\n",
    "n = np.arange(-10, 11)\n",
    "\n",
    "plt.stem(n,delta)\n",
    "plt.title('Impulso unitario')\n",
    "plt.ylabel('Amplitud $\\delta[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$u[n]=\\sum_{m=-\\infty}^{n}{\\delta[m]}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u1 = np.concatenate((np.zeros(10),np.ones(11)))\n",
    "u2 = np.concatenate((np.zeros(11),np.ones(10)))\n",
    "delta = u1-u2\n",
    "\n",
    "u = np.cumsum(delta) # Devuelve la suma acumulada de los elementos a lo largo de un eje dado\n",
    "n = np.arange(-10, 11)\n",
    "\n",
    "plt.stem(n,u)\n",
    "plt.title('Escalón unitario')\n",
    "plt.ylabel('Amplitud $u[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Otras señales de interes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rampa\n",
    "\n",
    "$$r[n]=\\begin{cases} n, \\text{para } n=0,1,... \\\\  0, \\text{para  } n\\neq -1,-2,... \\end{cases} =\\left\\lbrace \\ldotp \\ldotp \\ldotp ,0,0^{\\uparrow } ,1{} ,2,3,\\ldotp \\ldotp \\ldotp \\right\\rbrace$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/max/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:7: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
      "  import sys\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Muestras $n$')"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "u1 = np.concatenate((np.zeros(11),np.ones(10)))\n",
    "\n",
    "r = np.cumsum(u1)\n",
    "\n",
    "n = np.arange(-11, 10)\n",
    "\n",
    "plt.stem(n+1,r)\n",
    "plt.title('Rampa')\n",
    "plt.ylabel('Amplitud $r[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Secuencia exponencial de valores reales\n",
    "\n",
    "$$x\\left\\lbrack n\\right\\rbrack =a^n ,\\forall  n,a\\in \\Re$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = np.arange(0, 10)\n",
    "x = (0.9)**n\n",
    "\n",
    "plt.stem(n,x)\n",
    "plt.title('Exponencial')\n",
    "plt.ylabel('Amplitud $x[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Secuencia exponencial de valores complejos\n",
    "\n",
    "$$x\\left\\lbrack n\\right\\rbrack =e^{\\left(\\sigma +jw_0 \\right)n} ,\\forall n$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/max/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:4: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
      "  after removing the cwd from sys.path.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Muestras $n$')"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "n = np.arange(0, 10)\n",
    "x = np.exp((2+3j)*n) # Calcula la exponencial de todos los elementos de la matriz de entrada.\n",
    "\n",
    "plt.stem(n,abs(x))\n",
    "plt.title('Exponencial')\n",
    "plt.ylabel('Amplitud $x[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Secuencia senoidal\n",
    "\n",
    "$$x\\left\\lbrack n\\right\\rbrack =A cos\\left(w_0 n+\\theta_0 \\right),\\forall n$$\n",
    "\n",
    "Donde A es la amplitud y $\\theta_0$ es la fase en radianes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/max/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:8: UserWarning: In Matplotlib 3.3 individual lines on a stem plot will be added as a LineCollection instead of individual lines. This significantly improves the performance of a stem plot. To remove this warning and switch to the new behaviour, set the \"use_line_collection\" keyword argument to True.\n",
      "  \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "Text(0.5, 0, 'Muestras $n$')"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "A = 1\n",
    "w0 = 2*np.pi*2\n",
    "n = np.linspace(0, 100,200)\n",
    "#O = -np.pi/2\n",
    "O = 0\n",
    "x = A*np.cos(w0*n)\n",
    "\n",
    "plt.stem(n,x)\n",
    "plt.title('Senoidal')\n",
    "plt.ylabel('Amplitud $x[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Secuencia aleatoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.random.seed(0) # fijar semilla\n",
    "n = np.arange(0,10)\n",
    "x = np.random.standard_normal(10)\n",
    "\n",
    "plt.stem(n,x)\n",
    "plt.title('Aleatoria')\n",
    "plt.ylabel('Amplitud $x[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funcion Sinc\n",
    "\n",
    "$$sinc[n]=\\begin{cases} \\frac {sen(n)}{n}, \\text{si } n \\neq 0 \\\\  1, \\text{caso contrario  } \\end{cases}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = np.arange(-10,11)\n",
    "s = np.sin(n)/(n)\n",
    "s[10] = 1\n",
    "\n",
    "plt.stem(n,s)\n",
    "plt.title('Sinc')\n",
    "plt.ylabel('Amplitud $x[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": [
     "prueba"
    ]
   },
   "source": [
    "> Más funciones matemáticas en la [documentación oficial](https://numpy.org/doc/stable/reference/routines.math.html). En particular señales en el siguiente [apartado](https://docs.scipy.org/doc/scipy/reference/signal.html#waveforms)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pulso unitario desplazado y escalado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mov = -2\n",
    "ampl = 2\n",
    "\n",
    "ini = -3\n",
    "fin = 4\n",
    "n = np.arange(ini,fin+1)\n",
    "delta = ampl*np.concatenate((np.zeros(abs(ini)- mov), np.ones(1), np.zeros(fin + mov)))\n",
    "\n",
    "plt.stem(n,delta)\n",
    "plt.title('Pulso unitario')\n",
    "plt.ylabel('Amplitud $\\delta[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escalón unitario desplazado y escalado"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mov = -2\n",
    "ampl = 2\n",
    "\n",
    "ini = -3\n",
    "fin = 4\n",
    "n = np.arange(ini,fin+1)\n",
    "\n",
    "U = ampl*np.concatenate((np.zeros(abs(ini) - mov), np.ones(1), np.ones( fin + mov)))\n",
    "\n",
    "\n",
    "plt.stem(n,U)\n",
    "plt.title('Sinc')\n",
    "plt.ylabel('Amplitud $x[n]$')\n",
    "plt.xlabel('Muestras $n$')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de datos\n",
    "\n",
    "Los **argumentos** que se deben indicar para crear el array son dos: los **elementos que contendrá**, que se ingresan en forma de lista, y el **tipo de datos** que tendrá la lista. En los ejemplos anteriores no especificamos el tipo de datos, ya que éste se asigna automáticamente al crear la lista. No obstante, es recomendable indicarlo siempre ya que cada tipo de datos ocupa un espacio en memoria distinto.\n",
    "\n",
    "Los tipos de datos que podemos utilizar dentro de un array son los siguientes:\n",
    "* **Números enteros** de 8, 16, 32 y 64 bits, con signo y sin signo.\n",
    "* **Números complejos** de 64 y 128 bits.\n",
    "* **Números de punto flotante** de 16, 32, 64 y 128 bits\n",
    "* **Booleanos** (‘True’ o ‘False’), **strings**, **bytes...**\n",
    "\n",
    "En el caso del array 'a' que creamos anteriormente, el formato que se asigna automáticamente es un entero de 64 bits con signo (int64). Nos resulta conveniente utilizar un formato entero sin signo y de 8 bits, de acuerdo a los datos que contiene. El formato se especifica de la siguiente forma:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([1,2,5,9], dtype = np.uint8)\n",
    "\n",
    "# la consola nos muestra el array\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este caso, definimos un array 'b' con un formato adecuado. Entonces, ¿cómo elegimos un tipo de datos conveniente para nuestros arrays? En la siguiente tabla podemos ver los rangos de valores para cada tipo de dato:\n",
    "\n",
    "| Tipo | Rango | Precisión |\n",
    "| ---  | ---   | --- |\n",
    "| int8 | -128 a 127 | |\n",
    "| int16 | -32768 a 32767 | |\n",
    "| int32 | -2147483648 a 2147483647 | |\n",
    "| int64 | -9223372036854775808 a 9223372036854775807 | |\n",
    "| uint8 | 0 a 255 | |\n",
    "| uint16 | 0 a 65535 | |\n",
    "| uint32 | 0 a 4294967295 | |\n",
    "| uint64 | 0 a 18446744073709551615 | |\n",
    "| float16 | ± 65504 | Hasta 3 dígitos decimales |\n",
    "| float32 | ± 10^(38.53) | Hasta 6 dígitos decimales |\n",
    "| float64 | ± 10^(308.25) | Hasta 16 dígitos decimales |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De todo este despliegue de números podemos extraer las siguientes premisas:\n",
    "\n",
    "* Si utilizamos números **enteros positivos**, es conveniente usar un **formato sin signo** para aprovechar el rango de la mejor manera posible.\n",
    "* Si deseamos representar valores de **números reales**, utilizamos un **formato float**.\n",
    "* **Siempre debemos formatear nuestros arrays**. Si no lo especificamos, estaremos utilizando 64 bits (float o entero) para definir a cada elemento de la lista. Esto generalmente no es necesario, y es contraproducente en dos sentidos: consume excesivo espacio en memoria y afecta a la velocidad de los algoritmos, lo que se hace notable cuando trabajamos con arrays extensos (por ejemplo, un archivo wav de varios minutos).\n",
    "\n",
    "Contamos con algunos **comandos útiles para saber el tamaño de un array y de sus elementos** (cantidad de bytes que ocupa en memoria):\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# devuelve el número de bytes del array 'a'\n",
    "bytes_array_a = a.nbytes\n",
    "\n",
    "# devuelve el número de bytes que ocupa cada elemento de 'a'\n",
    "bytes_item_a = a.itemsize\n",
    "\n",
    "print (\"El array 'a' ocupa %r bytes, y cada uno de sus elementos ocupa %r bytes. \\n\" \n",
    "       % (bytes_array_a, bytes_item_a))\n",
    "\n",
    "print (\"Éstos son todos los formatos que admite Numpy:\")\n",
    "# devuelve el número de bytes que ocupan los elementos de cada tipo de datos disponibles en Numpy\n",
    "np.nbytes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Definamos el formato numerico mas conveniente\n",
    "\n",
    "Ahora veamos algunos ejemplos para poner en práctica lo que mencionamos. Definamos los formatos que son más convenientes para los siguientes arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-49-edb3784d9aed>, line 6)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-49-edb3784d9aed>\"\u001b[0;36m, line \u001b[0;32m6\u001b[0m\n\u001b[0;31m    arr_a = np.array(a, dtype = ) # completar\u001b[0m\n\u001b[0m                                ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "a = [-1, 0, 1] \n",
    "b = [0.2, 12.7,-30.52]\n",
    "c = [10**10, 12**10, 3**18, 0]\n",
    "d = [3 + 1j, -5j]\n",
    "\n",
    "arr_a = np.array(a, dtype = ) # completar\n",
    "arr_b = np.array(b, dtype = ) # completar\n",
    "arr_c = np.array([c], dtype = ) # completar\n",
    "arr_d = np.array([d], dtype = ) # completar\n",
    "\n",
    "print (\" array a: \", arr_a,\"\\n array b: \", arr_b, \"\\n array c: \", arr_c,\n",
    "      \"\\n array d: \", arr_d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'arr_a' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-48-846b9e6112fb>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0marr_a\u001b[0m\u001b[0;34m//\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'arr_a' is not defined"
     ]
    }
   ],
   "source": [
    "arr_a//2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Longitud y dimensiones de un array\n",
    "\n",
    "Los ejemplos mencionados hasta ahora han sido de arrays de dimensiones $1 x N$. Podemos crear **arrays de varias dimensiones** de la siguiente manera:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# array de dos dimensiones y longitud igual a 3\n",
    "b = np.array([[1,2,3],[3,2,1]], dtype = np.uint8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# array de tres dimensiones y longitud igual a 2\n",
    "c = np.array([[1,-1],[0,1],[-5,2]], dtype = np.int8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La **longitud** representa la cantidad de elementos que posee el array. Su valor, y el de las dimensiones de un array, se pueden obtener de la siguiente manera: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# devuelve la forma de un array, de la siguiente forma (n° de filas, n° de columnas)\n",
    "(dim1, dim2) = b.shape\n",
    "\n",
    "#longitud del array\n",
    "longitud = b.size\n",
    "\n",
    "print(dim1, dim2)\n",
    "print(longitud)\n",
    "\n",
    "len(b) #elementos en la primera dimensión"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros((2,3)) # matriz de ceros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones((5,7)) # matriz de unos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(36)\n",
    "a\n",
    "a.shape = (6,6) # reconstruir una matriz\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indezado en arrays\n",
    "\n",
    "Los **índices** se utilizan para indicar la posición de cada elemento de un array. De esta manera, podemos acceder al valor de una posición específica o extraer el valor de un grupo de elementos. Cada elemento posee una posición $[i,j]$, donde $i$ representa el número de fila y $j$ representa el número  de columna en que se ubica."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# devuelve el elemento de la posición [1,2] del array 'a', igual a 8.\n",
    "print(a[1,2])\n",
    "\n",
    "# devuelve el elemento de la posición [2,0] del array 'a', igual a 12.\n",
    "print(a[2,0])\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es importante tener en cuenta que los índices que se asignan se inician desde 0, por lo que si tengo 4 elementos, sus índices irán del rango de 0 a 3.\n",
    "Podemos **desplazarnos** dentro de una array, y **seleccionar** un rango de elementos utilizando la notación *[i: j: k]*, donde 'i' representa el índice a partir del cual nos desplazamos, 'j' es el índice en el cual nos detenemos y 'k' es el paso con el cual nos desplazamos a los elementos subsiguientes. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = [0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5, 4, 4.5] \n",
    "sec = np.array(s, dtype = np.float16)\n",
    "\n",
    "# desplazamiento a partir del 1° elemento, hasta el 8° (no inclusive), \n",
    "# en pasos de cada 2 elementos\n",
    "print (sec[0:8:2])\n",
    "\n",
    "# desplazamiento entre las mismas posiciones en pasos de a 1\n",
    "print (sec[:8])\n",
    "\n",
    "# desplazamiento desde la posición n-5 hasta la posición 9, siendo n la cantidad de elementos.\n",
    "print (sec[-5:9])\n",
    "\n",
    "# desplazamiento desde la posición 7 hasta la posición n-8, en pasos de 1 hacia atrás\n",
    "print (sec[7:-8:-1])\n",
    "\n",
    "# desplazamiento desde la posición 4 hasta el final del array\n",
    "print (sec[3:])\n",
    "\n",
    "# desplazamiento desde la posición 4 hasta el final del array en pasos de a tres\n",
    "print (sec[3::3])\n",
    "\n",
    "# desplazamiento desde el comienzo hasta la posición 6 en pasos de a 2\n",
    "print (sec[:6:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como se puede ver en el ejemplo, tenemos varias opciones para desplazarnos de distintas maneras. Es posible ir hacia adelante, atrás e indicar las posiciones inicial y final con respecto a la longitud del array. Notemos que el elemento $j$, que indica el fin del desplazamiento, no se incluye en el resultado. Es decir, el resultado nos arroja los **elementos desde $i$ hasta $j-1$**.\n",
    "\n",
    "Para el caso de **matrices**, el desplazamiento es similar, contando con algunas opciones adicionales. Veamos algunos casos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# definimos la misma secuencia, pero en forma de matriz de 3x3\n",
    "fibo_mtx = np.array([[0,1,1],[2,3,5],[8,13,21]], dtype = np.uint8)\n",
    "\n",
    "# el desplazamiento es ahora entre dimensiones, para ver las dos primeras (filas 0 y 1):\n",
    "print(fibo_mtx[0:2], \"\\n\")\n",
    "\n",
    "# veo elementos de la submatriz de 2x2 (primeras dos filas y dos columnas):\n",
    "print(fibo_mtx[0:2,0:2], \"\\n\")\n",
    "\n",
    "# desplazamiento entre los dos primeros elementos de la 3° fila \n",
    "print(fibo_mtx[2,0:2], \"\\n\")\n",
    "\n",
    "# desplazamiento entre filas:\n",
    "print(fibo_mtx[0:2,0::], \"\\n\")\n",
    "\n",
    "# desplazamiento entre los elementos de la 2° columna \n",
    "print(fibo_mtx[...,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La notación *[i , j, k]* sirve para desplazarnos entre filas de una matriz. Por otra parte, podemos acceder a todos los elementos de una columna o fila con la notación *[..., x]* o *[x, ...]* respectivamente, siendo *x* el índice de la columna o fila en la que nos desplazamos.\n",
    "\n",
    "> **Nota:** Numpy también cuenta con el objeto matrix, que es una subclase del objeto array. La ventaja de usar este objeto es que las operaciones matemáticas son matriciales por defecto, y en un array se hacen elemento a elemento (vamos a este tema en la siguiente sección). A fines prácticos, el array también se puede implementar como matriz, teniendo en consideración lo mencionado anteriormente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Apliquemos lo visto en un ejercicio\n",
    "\n",
    "Apliquemos lo visto sobre índices y desplazamiento en un ejercicio. Éste comienza con la creación de un array a partir de una función. Python nos permite crear objetos llamados funciones para generar una instancia de una función matemática. En este caso, nos valemos de esta cómoda funcionalidad para crear un array con los valores de esa función en un conjunto finito de valores dentro de su dominio."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# creacion de un array a partir de una función\n",
    "func = lambda y,x : 0.5*x + np.cos(y)  # creo un objeto 'funcion'\n",
    "sec = np.fromfunction(func, (3,5), dtype = np.float16)  # armo array con la función fromfunction\n",
    "sec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imprimir la cantidad de filas y columnas del array\n",
    "print()  # completar\n",
    "print(\"\\n\")\n",
    "\n",
    "# imprimir el valor de la función en el punto (x,y)=(0,0)\n",
    "print()  # completar\n",
    "print(\"\\n\")\n",
    "\n",
    "# imprimir los valores de la función para x(i) con i = (1,3) e y(j) con j = (1,2)\n",
    "print()  # completar\n",
    "print(\"\\n\")\n",
    "\n",
    "# imprimir los valores de la función para x(i) con i = (0, 2, 4)\n",
    "print()  # completar\n",
    "print(\"\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Referencias\n",
    "\n",
    " * *Numpy User Guide*, https://www.numpy.org/\n",
    " * Scott, Shell, *An introduction to Numpy and Scipy*, 2014. \n",
    " * Martín, Gaitán. *Curso de Python para ciencias e ingenierías*. Extraido de [GitHub](https://github.com/mgaitan/curso-python-cientifico), 2017.\n",
    " * Oppenheim, Alan V.; Willsky, Alan S.; Nawab, S. Hamid. Señales y sistemas. Pearson Educación, 1998."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Licencia\n",
    "\n",
    "<a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\"><img alt=\"Licencia de Creative Commons\" style=\"border-width:0\" src=\"https://i.creativecommons.org/l/by-sa/4.0/88x31.png\" /></a><br />Este documento se destribuye con una <a rel=\"license\" href=\"http://creativecommons.org/licenses/by-sa/4.0/\">licencia Atribución CompartirIgual 4.0 Internacional de Creative Commons</a>.\n",
    "\n",
    "Material adaptado del curso [Introducción a Python](https://github.com/infiniemlabs-acustica/python_introduccion)\n",
    "\n",
    "© 2020. Infiniem Labs Acústica. infiniemlab.dsp@gmail.com (CC BY-SA 4.0))"
   ]
  }
 ],
 "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.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}