Tema1.Intro2Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# MANUAL DE LABORATORIO DE COMUNICACIONES DIGITALES CON PYTHON\n",
    "F. Javier Payán Somet, Juan José Murillo-Fuentes, José Carlos Aradillas Jaramillo \\\n",
    "_Departamento de Teoría de la Señal y Comunicaciones_ \\\n",
    "_Escuela Técnica Superior de Ingeniería_ \\\n",
    "_Universidad de Sevilla_ \n",
    "\n",
    "# Tema 1 – Introduction a Python para Comunicaciones Digitales\n",
    "\n",
    "**Este notebook contiene código del Tema 1**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table align=\"left\">\n",
    "  <td>\n",
    "    <a target=\"_blank\" href=\"https://colab.research.google.com/github/gapsc-us/labcomdig/blob/main/Tema1.Intro2Python.ipynb\"><img src=\"https://www.tensorflow.org/images/colab_logo_32px.png\" />Run in Google Colab</a>\n",
    "  </td>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inicialización"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Nos aseguramos primero de que se incluyen algunos módulos necesarios con las versiones adecuadas así como que Python 3 está instalado, se sugiere usar 3.5 aunque una inferior podría funcionar. Se comprueba que la versión de Numpy es igual o superior a 1.16. También, que las figuras con MatplotLib se incluyen \"inline\" y preparamos una función para salvar figuras. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python ≥3.5 is required\n",
    "import sys\n",
    "assert sys.version_info >= (3, 5)\n",
    "\n",
    "# Numpy ≥1.16 is required\n",
    "import numpy as np\n",
    "assert np.__version__ >= \"1.16\"\n",
    "\n",
    "# Common imports\n",
    "import os\n",
    "\n",
    "# to make this notebook's output stable across runs\n",
    "np.random.seed(42)\n",
    "\n",
    "# To plot pretty figures\n",
    "%matplotlib inline\n",
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "mpl.rc('axes', labelsize=14)\n",
    "mpl.rc('xtick', labelsize=12)\n",
    "mpl.rc('ytick', labelsize=12)\n",
    "\n",
    "# Where to save the figures\n",
    "DIRECTORIO_RAIZ_PROYECTO = \".\"\n",
    "CAPITULO_ID = \"intro\"\n",
    "PATH_IMAGES = os.path.join(DIRECTORIO_RAIZ_PROYECTO, \"images\", CAPITULO_ID)\n",
    "os.makedirs(PATH_IMAGES, exist_ok=True)\n",
    "\n",
    "def save_fig(fig_id, tight_layout=True, fig_extension=\"png\", resolucion=300):\n",
    "    path = os.path.join(PATH_IMAGES, fig_id + \".\" + fig_extension)\n",
    "    print(\"Saving figure\", fig_id)\n",
    "    if tight_layout:\n",
    "        plt.tight_layout()\n",
    "    plt.savefig(path, format=fig_extension, dpi=resolucion)\n",
    "\n",
    "# Ignore useless warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(action=\"ignore\") #Ignorar warnings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Primeras líneas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " print(\"Hola mundo\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Comentario: representamos un seno\n",
    "x=np.linspace(-10.,10., 1000) # Comenzamos por definir el eje de abcisas\n",
    "\n",
    "''' \n",
    " Párrafo con comentarios:\n",
    " A continuación representamos la figura \n",
    "'''\n",
    "plt.figure(figsize=(10, 4)) #Muy similar a Matlab/Octave\n",
    "plt.plot(x,np.sin(x))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aspectos Básicos\n",
    "### Primeros pasos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1+2+3+4+5\n",
    "+6+7+8 #En Jupyter se sigue con la línea de debajo\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En línea de comando se usaría `/` Permite dividir línea en dos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = (1+2+3+4+5+ #Permite dividir línea en dos usando paréntesis\n",
    "6+7+8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = x+y; w = x-y #dos sentencias en una línea, aunque no se recomienda\n",
    "# Se prefiere\n",
    "z = x+y\n",
    "w = x-y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los espacios son importantes en Python, en particular en los bucles y condicionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "for i in range(10):   #Luego se introducirán más ejemplos de bucles\n",
    "    total += i\n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El resultado es diferente si se introducen espacios delante del print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "for i in range(10):   #Luego se introducirán más ejemplos de bucles\n",
    "    total += i\n",
    "    print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En Python las variables son objetos y se puede acceder a sus atributos y métodos, de diferentes formas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 3.25\n",
    "print(x.real, \"+\" , x.imag, \"i\")\n",
    "x.as_integer_ratio()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(3.25.real, \"+\" , 3.25.imag, \"i\")\n",
    "3.25.as_integer_ratio()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x.as_integer_ratio()\n",
    "float.as_integer_ratio(x)\n",
    "float.as_integer_ratio(3.25)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No hay que declarar el tipo..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4\n",
    "print(type(x))\n",
    "x = 'Comunicaciones Digitales'\n",
    "print(type(x))\n",
    "x = [1,2,3]\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las variables en realidad son punteros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [1, 2, 3]\n",
    "y = x\n",
    "print(y)\n",
    "x.append(4) #añade 4 a la lista apuntada por x\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = [5, 6, 7]\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos Mutables e inmutables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L = ['pam', 'psk', 'qam'] # Una lista de tres datos del tipo str 2\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L.append('fsk')\n",
    "L"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dir(L)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "L.reverse()\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los tipos de variables inmutables no admiten modificación:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = ('pam', 'psk', 'qam', 'fsk')\n",
    "# T.reverse()  #Try to uncomment and run to see an error, for it is \n",
    "  #inmutable "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uso de import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy  \n",
    "a=numpy.array([1,2,3])\n",
    "a\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import array\n",
    "a = array([1, 2, 3])\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np #We already did this at the very start of \n",
    "   #the notebook\n",
    "a = np.array([1, 2, 3])\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### La clase `ndarray` de NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A.ndim)\n",
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1],[2],[3],[4],[5]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A.ndim)\n",
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1, 2, 3, 4, 5])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A.ndim)\n",
    "print(A.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Afila = A[np.newaxis,:]\n",
    "Afila"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Afila.shape)\n",
    "print(Afila.ndim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Acol = A[:,np.newaxis]\n",
    "Acol"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(Acol.shape)\n",
    "print(Acol.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Código 1.1**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 2], [3, 4], [5, 6]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(A.shape)\n",
    "print(np.shape(A))\n",
    "print(A.size)\n",
    "print(np.ndim(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([1, 2, 3, 4, 5, 6])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(B.ndim)\n",
    "print(B.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C = np.array([[1, 2, 3, 4, 5, 6]])\n",
    "C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(C.ndim)\n",
    "print(C.shape)\n",
    "print(A.nbytes)\n",
    "print(C.nbytes)\n",
    "print(C.dtype)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Construcción de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([1,2,3]) # Definición de un array de una dimensión (1-D).\n",
    "print('A=',A)\n",
    "print(\"No̲ de dimensiones de A:\", A.ndim, \", Shape de A:\", A.shape)\n",
    "\n",
    "# Definición de un array dos dimensiones (2-D) ( 1,3) (vector fila).\n",
    "B = np.array([[1,2,3]]) \n",
    "print('B=',B)\n",
    "#Obsérvese el doble corchete.\n",
    "print(\"No̲ de dimensiones de B:\", B.ndim, \", Shape de B:\", B.shape)\n",
    "\n",
    "# Definición de un array dos dimensiones (2- D) (3,1) (vector columna).\n",
    "C = np.array([[1],[2],[3]]) \n",
    "print('C=',C)\n",
    "print(\"No̲ de dimensiones de C:\", C.ndim, \", Shape de C:\", C.shape)\n",
    "\n",
    "D = np.array([[[0], [1], [2]]])\n",
    "print('D=',D)\n",
    "print(\"No̲ de dimensiones de D:\", C.ndim, \", Shape de C:\", C.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generación de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(9) #Un array 1-D formado por números comprendidos\n",
    "#entre 0 y 9, excluyendo el 9\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.arange(1, 8, 2) # Un array 1-D formado por números comprendidos\n",
    "#entre 1 y 8 de dos en dos\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Arrays incrementados linealmente o logarítmicamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linspace(0, 10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linspace(0, 10, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.logspace(0, 2, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.logspace(0,8,10, base=2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indicando nombre parámetros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.arange(start=1,stop=9)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.arange(start=1,stop=8,step=2)\n",
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vectores de ceros y unos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.zeros([2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones(4).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones([4,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones([4,2], dtype=np.complex64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.ones([4,2], dtype=np.complex64).dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.diag([1,2,3,4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.diag([1,2,3,4],k=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.diag([1,2,3,4],k=-1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.eye(3,4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Generación de números aleatorios"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.rand(1, 10) #Genera un array 2-D (1,10) de valores de una \n",
    "# va uniformemente distribuida entre [0, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.randint(-5,5, [1,10]) #Genera un array 2-D (1,10) de valores de una \n",
    "#va discreta uniformemente distribuida entre [-5, 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.randint(-5,5, [1,10]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*np.random.randn(1,10)+1 #Genera un array 2-D (1,10) de valores de una\n",
    "#v.a. gaussiana de media 1 y varianza 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operador `np.kron`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,0,2,0,3]])\n",
    "B = np.array([[1,2,3]])\n",
    "np.kron(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Concatenación y separación de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2]]); b = np.array([[3, 4]]); c = np.array([[5],[6]])\n",
    "np.concatenate([a,b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.concatenate([a,c]) #try, will prompt an error because of dimensions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.concatenate([b,a,b])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=np.concatenate([a, b])\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=np.concatenate([b, a])\n",
    "e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.concatenate([d,e])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.concatenate([d,e],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(d,e,axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(d,e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.r_[b,a,b]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.c_[d,c]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.c_[d,e]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([1,2,3])\n",
    "x.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[9,8,7],[4,5,6]])\n",
    "A.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.vstack([x,A]) # Apilar verticalmente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.vstack([A,x])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = np.array([[0],[0]])\n",
    "y.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.hstack([y,A])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.random.randint(1,50, size=[6,6]) # Generación de una matriz de \n",
    "#enteros aleatorios siguiendo una distribución uniforme \n",
    "#entre [1,50) (no incluye el 50), de tamaño 6x6\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A1, A2, A3 = np.split(A, [3,5])\n",
    "A1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Direccionamiento de los elementos de un array de una dimensión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[3:7]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[0:7:2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[8:0:-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Direccionamiento de los elementos de un array multidimensional"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " np.random.seed(8) # Permite cambiar la semilla \n",
    "    # del generador aleatorio"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.random.randint(1,50, size=[6,6]) # Generación de \n",
    "# una matriz de enteros aleatorios siguiendo una \n",
    "#distribución uniforme entre [1,50), (no incluye el 50). \n",
    "# De tamaño 6x6\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1,:] # Selecciona completa la fila 1 \n",
    "# (recuérdese que la numeración comienza con el 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1,] # Selecciona completa la \n",
    "# fila 1 (una expresión equivalente)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[:,2] # Selecciona completa la columna 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[3:5] # Selecciona las filas 3 hasta la 5 \n",
    "# (excluyendo la 5). A[3:5,] es una expresión equivalente"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[:,3:5] # Selecciona las columnas 3 hasta la 5 \n",
    "# (excluyendo la 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[[1,2,4],:] # Selecciona las filas 1, 2, 4 completas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[5,1:4] # De la fila 5, selecciona los elementos entre \n",
    "# las columnas 1 a 4, excluyendo el de la columna 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[1:3,3:] # De las filas 1 a 3 (excluyendo la 3), \n",
    "#selecciona los elementos de la columna 3 hasta el final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A[-1,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(8) # Para obtener mismo resultados \n",
    "A = np.random.randint(1,50,size=[6,6])\n",
    "B = np.eye(np.shape(A)[0]) #np.shape(A)[0] devuelve \n",
    "# el tamaño de la dimensión 0 de la matriz A. Recordad \n",
    "# que np.shape(A) o A.shape devuelve un secuencia (tuple) \n",
    "# con el número de elementos de A en cada eje"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B[[1,3,4],:]=A[0:3,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Incremento y reducción de dimensiones de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aumentamos dimensiones de array de un elemento\n",
    "A = np.array(5)\n",
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array(5); A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R1 = np.expand_dims(B,axis=0)\n",
    "R1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R2 = A[np.newaxis]; \n",
    "R2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R2 = A[np.newaxis]\n",
    "R2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R3 = A[None]\n",
    "R3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R4 = A.reshape(-1,)\n",
    "R4.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generamos la segunda dimension, tiene que estar creada \n",
    "#la primera\n",
    "C1 = np.expand_dims(R1,axis=1) \n",
    "C1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C2 = R2[np.newaxis]\n",
    "C2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C3 = R3[None]\n",
    "C3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C4 = R4.reshape(1,1)\n",
    "C4.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([1, 2, 3])\n",
    "B.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R1 = np.expand_dims(B,axis=0)\n",
    "R1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Es interesante ver que al forzar incluir la primera \n",
    " #dimensión, pasa los datos a la segunda\n",
    "R2 = B[np.newaxis]\n",
    "R2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R3 = B[None]\n",
    "R3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "R4 = B.reshape(-1,)\n",
    "R4.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C1 = np.expand_dims(B,axis=1)\n",
    "C1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C2 = B[:,np.newaxis]\n",
    "C2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C3 = B[:,None]\n",
    "C3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C4 = B.reshape(-1,1)\n",
    "C4.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Aumentamos en varias dimensiones un array de \n",
    "# varios elementos\n",
    "C = np.array([1, 2, 3, 4, 5])\n",
    "C.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V1 = C[np.newaxis,:,np.newaxis,np.newaxis,np.newaxis]\n",
    "V1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V2 = C[None,:,None,None,None]\n",
    "V2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "V3 = C.reshape(1,-1,1,1,1)\n",
    "V3.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eliminamos dimensiones:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[[0], [1], [2]]])\n",
    "x.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1 = np.squeeze(x)\n",
    "x1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x2 = np.squeeze(x, axis=(0,))\n",
    "x2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x3 = np.squeeze(x, axis=(2,))\n",
    "x3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x3.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x4 = x.reshape(-1)\n",
    "x4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x4.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulación de dimensiones y formas (`shape`) de arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.random.randint(1,50, size = [4,4])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.flatten()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(A,[[0,0,0],[1,2,3]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(A, [[0,0,0,0]], axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.append(A, [[0],[0],[0],[0]], axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A.reshape([2,8])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.reshape(A,[2,8], order='C')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.reshape(A,[2,8], order='F')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(6).reshape([3,2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(6).reshape([3,2], order='F')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operaciones con arrays"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,3],[4,2]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B = np.array([[1,1],[1,0]])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "E = np.dot(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "F = np.dot(A,np.linalg.inv(B))\n",
    "F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(F,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = np.linalg.solve(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.dot(A,G)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H=A+1j*B\n",
    "H"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H.conjugate().T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "H.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.linalg.matrix_power(A,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A**B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1,2,3])\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.vdot(a,a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2,-1],[-3,-1,1],[1,-1,1]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([[5],[8],[0]])\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linalg.solve(A,b)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Texto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.4235                                                  \n",
    "b = 7                                                       \n",
    "print('A vale %.2f y b vale %d' % (a,b)) #f float, d decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3.4235                                                  \n",
    "b = 7                                                       \n",
    "print('A vale {:.2f} y b vale {}'.format(a,b)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operadores relacionales y lógicos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1,2],[3,4]])\n",
    "B=np.array([[1,0],[5,4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A==B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A>B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A!=B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.sum(A!=B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 7-a\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.logical_and(a>b, b>2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = np.logical_or(a<b, b<2)\n",
    "r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.logical_not(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Utilización de la función `np.where`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[3, -1, 4, 0, -8, 0, 2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=x[np.where(x)]\n",
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.array([[3, -1, 4, 0, -8, 0, 2]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(x>=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z=x[np.where(x>=2)]\n",
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Gráficos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#%matplotlib  #descomentar para que la figura no aparezca\n",
    "# dentro del noteboook sino como una figura nueva\n",
    "import matplotlib.pyplot as plt\n",
    "t = np.arange(0,5*np.pi,0.1)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(t,np.sin(t))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0,5*np.pi,0.1)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(t,np.sin(t))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.style.use('seaborn-whitegrid')\n",
    "fig, ax = plt.subplots()\n",
    "t = np.arange(0,5*np.pi,0.1)\n",
    "ax.plot(t,np.sin(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones gráficas elementales 2D"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Función `stem`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "N = np.arange(60)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.stem(np.sin(N*np.pi/12))\n",
    "plt.axis([-1,61,-1.1,1.1])\n",
    "plt.grid()\n",
    "plt.show()\n",
    "save_fig(\"stem\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Función `plot`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0,5*np.pi,0.1)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(t,np.sin(t), '*-r')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0,5*np.pi,0.1)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(t,np.sin(t),'-.rs', linewidth=4, markeredgecolor='k', markerfacecolor='g', markersize=10)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0,5*np.pi,0.1)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.plot(t,np.sin(t)) \n",
    "plt.plot(t,np.sin(t)**2-1)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(0,10,1000) \n",
    "y1 = (x/2)**2\n",
    "y2 = x**2\n",
    "y3 = 4 + (x/2)**2\n",
    "plt.plot(x,y1,x,y2,x,y3) \n",
    "plt.title('Polinomios de x')\n",
    "plt.xlabel('$x$') \n",
    "plt.ylabel('$f(x)$')\n",
    "plt.legend(['$(x/2)^2$','$x^2$','$4 + (x/2)^2$']) \n",
    "plt.grid('on')\n",
    "plt.show()\n",
    "save_fig(\"Polinomios\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Igual pero utilizando clases\n",
    "fig, ax = plt.subplots()\n",
    "x = np.linspace(0,10,1000) \n",
    "y1 = (x/2)**2\n",
    "y2 = x**2\n",
    "y3 = 4 + (x/2)**2\n",
    "ax.plot(x,y1,x,y2,x,y3)\n",
    "ax.set(xlabel='x', ylabel='f(x)', title='Polinomios de $x$')\n",
    "ax.legend(['$(x/2)^2$','$x^2$','$4 + (x/2)^2$'])\n",
    "ax.grid('on')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comando `subplot`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = np.arange(0,5*np.pi,0.1)\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.subplot(2,2,1), \n",
    "plt.title('$Sen(x)$'), plt.plot(t,np.sin(t))\n",
    "plt.subplot(2,2,2), \n",
    "plt.title('$Cos(x)$'), plt.plot(t,np.cos(t))\n",
    "plt.subplot(2,2,3), \n",
    "plt.title('$Sen^{2}(x)$'), plt.plot(t,np.sin(t)**2) \n",
    "plt.subplot(2,2,4), \n",
    "plt.title('$Cos^{2}(x)$'), plt.plot(t,np.cos(t)**2)\n",
    "plt.tight_layout() # Para que no se solapen las subfiguras\n",
    "#Alternativamente se puede usar:\n",
    "#plt.subplots_adjust(hspace=0.5)\n",
    "plt.show()\n",
    "save_fig(\"subplots\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones gráficas elementales 3D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "fi = np.arange(0,6*np.pi,np.pi/20) \n",
    "fig = plt.figure(figsize=(10, 4))\n",
    "ax2d = fig.add_subplot(1, 2, 1)\n",
    "ax3d = fig.add_subplot(1, 2, 2, projection='3d')\n",
    "ax2d.plot(np.cos(fi),np.sin(fi)), \n",
    "ax2d.grid(), ax2d.axis('square')\n",
    "ax3d.plot(np.cos(fi),\n",
    "np.sin(fi),fi), \n",
    "ax3d.grid()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "# Crea la rejilla de valores X, Y \n",
    "# cuando x varía entre (-3,3) e y varía entre (-3 ,3)\n",
    "x = np.arange(-3, 3, 0.1) #0.01)\n",
    "y = np.arange(-3, 3, 0.1) #0.01)\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "# Definición de la función a representar\n",
    "Z=(1/(2*np.pi))*np.exp(-X**2-Y**2)*0.5\n",
    "\n",
    "ax.plot_surface(X, Y, Z, cmap=plt.get_cmap('Spectral_r'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.cm as cm\n",
    "\n",
    "fig = plt.figure()\n",
    "ax = fig.gca(projection='3d')\n",
    "\n",
    "# Crea la rejilla de valores X, Y \n",
    "# cuando x varía entre (--10,10) e y varía entre (-10,10)\n",
    "\n",
    "x = np.arange(-10, 10, 0.1) #0.03)\n",
    "y = np.arange(-10, 10, 0.1) #0.03) \n",
    "\n",
    "X, Y = np.meshgrid(x, y)\n",
    "\n",
    "R=np.sqrt(X**2 + Y**2)\n",
    "Z=np.sin(R)/R \n",
    "ax.plot_surface(X, Y, Z)\n",
    "ax.plot_surface(X, Y, Z, cmap=cm.Spectral_r)\n",
    "save_fig(\"hat\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Programación en Python: bifurcaciones y bucles"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencia `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "condicion1 = 0\n",
    "condicion2 = 1\n",
    "condicion3 = 1 #No se comprueba si alguna anterior no es cero \n",
    "bloque2 = 2, \n",
    "bloque3 = 3, \n",
    "bloque4 = 4\n",
    "\n",
    "if condicion1:\n",
    "    print(bloque1) # Indentación\n",
    "elif condicion2: print(bloque2) #linea continua \n",
    "elif condicion3: \n",
    "    print(bloque3)\n",
    "else: # Opción por defecto cuando no se cumplen las condiciones 1, 2, 3 \n",
    "    print(bloque4) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencia `while`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sentencia=10\n",
    "while condicion3 < 10:\n",
    "    condicion3 += 1\n",
    "    print(sentencia)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sentencia `for'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "objeto=np.arange(5)\n",
    "for k in objeto: # Asigna a k los elementos del objeto\n",
    "    print(sentencia) # Cuerpo que se repite. Utiliza k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in objeto: # Asigna a k los elementos del objeto sentencias # Cuerpo que se repite. Utiliza k\n",
    "    print(sentencia) # Se ejecutarán si no se ha salido con break\n",
    "    if k == 4:\n",
    "        break\n",
    "else: # Una parte opcional\n",
    "    print(sentencia) # Se ejecutarán si no se ha salido con break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=0\n",
    "for k in range(2,100,2):\n",
    "    s=s+k\n",
    "    \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "T = ('PAM', 'QAM', 'PSK', 'OQPSK') \n",
    "for k in T: print(k, end = ' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.array([[1, 2],[5, 6]])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in A:\n",
    "    print(k)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ficheros de comandos y funciones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funciones "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mifuncion(entrada01, entrada02): # cuerpo de la función\n",
    "    salida01 = entrada01\n",
    "    salida02 = entrada02\n",
    "    return [salida01, salida02]\n",
    "\n",
    "a , b = mifuncion(2,3)\n",
    "a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Qfunct(x): \n",
    "    '''\n",
    "    y = Qfunct(x) evalúa la función Q en x.\n",
    "    Donde y = 1/sqrt(2*pi) * integral desde x hasta inf de exp(-t^2/2) dt\n",
    "    '''\n",
    "    from scipy.special import erfc\n",
    "    from math import sqrt \n",
    "    y=(1/2)*erfc(x/sqrt(2))\n",
    "    return y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(Qfunct)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evitando errores comunes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import pi, sin # En este caso se ha importado \n",
    "# pi y sin para evitar tener que escribir np.pi y np.sin\n",
    "from matplotlib.pyplot import plot, axis #En este caso \n",
    "# se ha importado plot y axis para evitar tener que \n",
    "# escribir plt.plot y plt.axis\n",
    "plt.figure(figsize=(16, 6))\n",
    "x = np.arange(0,3*pi,pi/100) \n",
    "y = sin(x)\n",
    "y = y*(y>0) # Importante ver esta línea y el papel de (y>0)\n",
    "plot(x,y)\n",
    "axis([0, 3*pi, 0, 1.1]) \n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eps = sys.float_info.epsilon # sis se cargó al comienzo\n",
    "x = np.arange(-4*pi,4*pi,pi/100) \n",
    "x = x+(x==0)*eps  # Evita dividir por cero!!\n",
    "plt.figure(figsize=(10, 4))\n",
    "plot(x,sin(x)/x) \n",
    "axis([-15, 15, -0.3, 1.1])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import tan\n",
    "from matplotlib.pyplot import grid, subplot\n",
    "\n",
    "eps=sys.float_info.epsilon\n",
    "x = np.arange(-(3/2)*pi,(3/2)*pi,pi/100)\n",
    "y = tan(x); subplot(1,2,1), plot(x,y)\n",
    "grid(True)\n",
    "y = y*(np.abs(y)<1e10);\n",
    "plt.figure(figsize=(10, 4))\n",
    "subplot(1,2,2), plot(x,y) \n",
    "grid('on') # True y 'on' son equivalentes\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import floor\n",
    "from numpy.random import randn, seed\n",
    "from time import time\n",
    "#from labcomdig import Qfunct\n",
    "\n",
    "seed(42)\n",
    "contador=0 \n",
    "N=10**7\n",
    "r = randn(N)+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "startTime = time() \n",
    "for k in r:\n",
    "    if k>0: \n",
    "        contador=contador+1\n",
    "\n",
    "t = time()-startTime\n",
    "teorico = floor((1-Qfunct(1))*N)\n",
    "print('mayores que 0: ' + str(contador)) \n",
    "print('mayores que 0 (teóricos): ' + str(teorico))\n",
    "print('tiempo transcurrido: ' + str(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "startTime = time()\n",
    "contador=sum(r>0)\n",
    "t = time()-startTime\n",
    "teorico = floor((1-Qfunct(1))*N)\n",
    "print('mayores que 0:   ' + str(contador))\n",
    "print('mayores que 0 (teóricos):   ' + str(teorico))\n",
    "print('tiempo transcurrido:   ' + str(t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import sum #Usamos el sum de numpy\n",
    "startTime = time()\n",
    "contador=np.sum(r>0)\n",
    "t = time()-startTime\n",
    "teorico = floor((1-Qfunct(1))*N)\n",
    "print('mayores que 0:   ' + str(contador))\n",
    "print('mayores que 0 (teóricos):   ' + str(teorico))\n",
    "print('tiempo transcurrido:   ' + str(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Otras técnicas de optimización"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Alternativa con bucle for\n",
    "from sympy import primerange\n",
    "\n",
    "tic=time() \n",
    "N=1000;\n",
    "s = 0;\n",
    "for j in primerange(1,N):\n",
    "    s=s+j\n",
    "print('suma de los ' +str(N) +' primeros números primos: ' +str(s)) \n",
    "print('tiempo transcurrido :' +str(time()-tic))\n",
    "# Alternativa sin bucle for\n",
    "startTime = time()\n",
    "s = np.sum(list(primerange(1,N)));\n",
    "print('suma de los ' +str(N) +' primeros números primos: ' +str(s))\n",
    "print('tiempo transcurrido :' +str(time()-startTime))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import randint\n",
    "from numpy import zeros \n",
    "\n",
    "# Alternativa con bucle for\n",
    "N = 100\n",
    "M = 100\n",
    "x = randint(10,size=(M,N))\n",
    "y = randint(10,size=(N,M)) \n",
    "z = zeros([M,M])\n",
    "tic = time()\n",
    "for k in range(M):\n",
    "    for l in range(M): \n",
    "        z[k,l]=np.sum(x[k,:]*y[:,l])\n",
    "print('tiempo transcurrido : ' +str(time()-tic))\n",
    "# Alternativa sin bucle for\n",
    "tic = time()\n",
    "z = np.dot(x,y)\n",
    "print('tiempo transcurrido : ' +str(time()-tic))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplo de criba de Eratóstenes Versión 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def criba01(lastNumber):\n",
    "    from numpy import mod, where, array\n",
    "    \n",
    "    List = list(range(2, lastNumber))\n",
    "    primeList = [];\n",
    "    \n",
    "    while(List[0]**2 <lastNumber):\n",
    "        \n",
    "        primeList.append(List[0]) \n",
    "        List = array(List)\n",
    "        \n",
    "        List = list(List[where(mod(List,List[0]))])\n",
    "\n",
    "    primeList.extend(List)\n",
    "    return primeList"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejemplo de criba de Eratóstenes Versión 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def criba02(x):\n",
    "    from NumPy import array, sqrt, arange \n",
    "    P = list(range(x))\n",
    "    P = array(P)\n",
    "    for n in range(2,int(sqrt(x))):\n",
    "        if P[n]: \n",
    "            P[arange(2*n,x,n)] = 0\n",
    "    P = P[P != 0] \n",
    "    return list(P)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simulación discreta de una señal de energía de duración finita"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Código 1.5**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Definamos los parámetros de la representación:\n",
    "T = 4e-3 # Duración\n",
    "L = 64 # Número de muestras que vamos a utilizar\n",
    "Tm = T/L #Tiempo de muestreo (Intervalo de separación entre muestras)\n",
    "\n",
    "t = np.arange(0,T,Tm) #Eje de tiempos.\n",
    "# Definición de la señal\n",
    "gt = np.ones(L) #La función evaluada en los puntos elegidos \n",
    "gt[L//2:] = -1\n",
    "# La representación continua\n",
    "plt.figure(1)\n",
    "h = plt.plot(t,gt) #Se representa gt frente t\n",
    "plt.axis([0, T, -1.1, 1.1])\n",
    "plt.setp(h,'linewidth',1.0) #Permite fijar el grosor de línea\n",
    "plt.ylabel('g(t)') #Etiqueta para el eje de ordenadas \n",
    "plt.xlabel('t(ms)') #Etiqueta para el eje de abscisas\n",
    "plt.show()\n",
    "save_fig(\"Continuous_Time_Pulse\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Código 1.6**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import ones\n",
    "from matplotlib.pyplot import axis, setp, ylabel, xlabel, show, stem\n",
    "# Observar que en este caso se han importado las funciones que se van a utilizar para evitar tener que escribir plt.axis, plt.ylabel...\n",
    "L = 64 # Número de muestras que vamos a utilizar\n",
    "# Definición de la señal de forma discreta\n",
    "g1n = ones(L) \n",
    "g1n[L//2:] = -1\n",
    "h = stem(g1n)\n",
    "axis([1,L,-1.1,1.1])\n",
    "setp(h,'linewidth',1.0)\n",
    "ylabel('$g_1(n)$') # Texto entre $$ formato formulas latex xlabel('n')\n",
    "show()\n",
    "save_fig(\"Discrete_Pulse\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Código 1.7**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import ones, sqrt, arange\n",
    "from matplotlib.pyplot import stem, axis, setp, ylabel, xlabel\n",
    "# Definamos los parámetros de la representación: T = 4e-3 # Duración de la representación\n",
    "L = 64 # Número de muestras que vamos a utilizar en la representación Tm = T/L # Tiempo de muestreo (Intervalo de separación entre muestras)\n",
    "t = arange(0,T,Tm) # Eje de tiempos.\n",
    "# Definicion de la señal continua\n",
    "gt = ones(L) # La función evaluada en los puntos elegidos\n",
    "gt[L//2:] = -1\n",
    "# La secuencia discreta normalizada\n",
    "g2n = sqrt(Tm)*gt\n",
    "# Su representación\n",
    "h = stem(g2n)\n",
    "axis( [-1, L+1, -sqrt(Tm)*1.1, sqrt(Tm)*1.1])\n",
    "setp(h,'linewidth', 1.0) \n",
    "ylabel('g_{2}(n)')\n",
    "xlabel('n');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Código 1.8**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Parámetros de diseño\n",
    "E = 4\n",
    "T = 4e-3\n",
    "L = 8\n",
    "\n",
    "# Tiempo entre muestras\n",
    "Tm = T/L\n",
    "\n",
    "# Señal discreta de energía E\n",
    "sn = np.ones(L)\n",
    "En = sn@sn   #Energía del pulso sin normalizar\n",
    "sn = np.sqrt(E/En)*sn\n",
    "\n",
    "# Energía de la señal discreta\n",
    "msg = 'Energía de la señal discreta sn: %.2f J'%(sn@sn) \n",
    "print (msg)\n",
    "\n",
    "# Definición de la señal continua\n",
    "st = np.sqrt(1/Tm)*sn\n",
    "\n",
    "# Energía de la señal continua\n",
    "msg = 'Energía de la señal continua st: %.2f J'%(st@st*Tm)\n",
    "print (msg)\n",
    "\n",
    "# Representación de las dos señales\n",
    "plt.figure(figsize=(10, 4))\n",
    "plt.subplot(1,2,1), plt.stem(sn, use_line_collection=True)\n",
    "plt.xlabel('n'), plt.ylabel('sn(n)')\n",
    "plt.axis([0,L+1, 0, max(sn)*1.1])\n",
    "t = np.arange(0,T,Tm)\n",
    "plt.subplot(1,2,2), plt.plot(t,st)\n",
    "plt.xlabel('t[s]'), plt.ylabel('st(t)')\n",
    "plt.axis([0, T, 0, max(st)*1.1])\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Ejercicio Propuesto\n",
    "<b>1.</b> Generar una secuencia $A_n$ de $N = 10$ números aleatorios de valores $\\pm2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>2.</b> Generar un pulso rectangular de energía unidad, $s(t)$, representado mediante $L=8$ muestras."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>3.</b> Representar la función que se obtiene si el pulso $s(t)$ se multiplica por la secuencia $A_n$ y se desplaza cada $T_b$ s. Esto es, obtener y representar X(t) definido por:\n",
    "\n",
    "$$\n",
    "X(t) = \\sum_{k=0}^9 A_k s(t-kT_b)\n",
    "$$.\n",
    "\n",
    "Mostrar explícitamente los valores máximos y mínimos que toma la señal así como su duración en segundos."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>4.</b>¿Cuál ha sido la energía total transmitida?¿Y la potencia?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<b>5.</b> Repetir lo anterior para un pulso senoidal de energía unidad $s(t)$, proporcional al mostrado en la Figura 1.25, duración $T_b=10^-3$ s, representado mediante $L=8$ muestras.\n",
    "\n",
    " <img src=https://raw.githubusercontent.com/gapsc-us/labcomdig/main/figures/pulsoSenoidalP1.png style=\"max-width:30%;width:auto;height:auto;\" align=\"center\">"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los apartados <b>2</b> y <b>3</b> tienen que hacerse en tiempo discreto y en tiempo continuo y convertirlo en el que no se haga originalmente. Valorar la ventaja de hacerlo en un sentido u otro y, en cualquier caso, obtener las respuestas en los dos marcos temporales."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.5"
  },
  "nav_menu": {
   "height": "264px",
   "width": "369px"
  },
  "toc": {
   "navigate_menu": true,
   "number_sections": true,
   "sideBar": true,
   "threshold": 6,
   "toc_cell": false,
   "toc_section_display": "block",
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}