diff --git a/Ejercico_1.ipynb b/Ejercico_1.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..01ed4b9cf869efadb8cd091e3e74e46170f21ab2
--- /dev/null
+++ b/Ejercico_1.ipynb
@@ -0,0 +1,343 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# **Tarea 3. Ejercicio 3.**\n",
+ "## Daniel Brito.\n",
+ "## @britod"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "* Investigue sobre el diagrama de Hertzsprung-Russell, una herramienta muy potente en astronomia, y describa un poco al respecto para darle contexto al resto de la tarea.\n",
+ "* El objetivo es generar un diagrama HR lo más parecido al de esta referencia. No lucirá idéntico por que no se usarán exactamente los mismos datos, y las unidades pueden ser ligeramente distinta. La idea sà es dejar su figura lo más parecida a la de referencia en el estilo: colores, escalas en los ejes, tamaño de los marcadores, leyendas, textos en el gráfico, etc.\n",
+ "* Los datos para crear la figura están en la carpeta Data. Cada tabla contiene las informaciones sobre un tipo de estrellas según indican los nombres de archivo. La información viene en 3 columnas: luminosidad en luminosidades solares, Temperatura en Kelvin y Radio de la estrella en unidades arbitrarias.\n",
+ "* La idea es que cada estrella en el gráfico tenga un color representativo de su temperatura (que estrellas frÃas son rojas y estrellas calientes son azules) y que el tamaño del sÃmbolo sea representativo del tamaño de cada estrella para diferenciar entre enanas, gigantes y estrellas de secuencia principal.\n",
+ "* Busque que su código sea semi automático; es indispensable leer los datos desde el propio programa, no copiarlos a mano, y hallar una forma de obtener los tamaños y colores sin declararlos uno a uno.\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "#### Solución:"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Un Diagrama de Hertzsprung-Russell es un gráfico de dispersión de estrellas en el cual se indica la relación entre las magnitudes absolutas o luminosidades de las estrellas respecto a sus clasificaciones espectrales (o las temperaturas) efectivas."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "El diagrama está organizado de la siguiente forma:\n",
+ "* El **eje horizontal** mide la temperatura superficial de las estrellas en grados kelvin, que va desde las temperaturas más altas hasta las temperaturas más bajas (de izquierda a derecha). Esta es la clasificación espectral, en la cual el color de las estrellas va desde un color azulado (mayor temperatura) al rojo (menor temperatura). Esto concuerda con el comportamiento de los cuerpos negros. A medida que aumenta la temperatura de una estrella, su color también cambia (como si de un metal en una fragua se tratara) yendo desde el rojo a un tono azulado, pasando antes por tonos naranjas y blancos.\n",
+ "* El **eje vertical**, al igual que en la anterior ocasión, mide el mismo concepto, aunque expresado con diferentes escalas: La luminosidad. En la parte izquierda se mide la luminosidad tomando como referencia al Sol (al que, como podéis ver, se le asigna el número 1), facilitando asà una identificación bastante intuitiva de la luminosidad del resto de estrellas, siendo la zona superior la más luminosa y la inferior la menos luminosa."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Importamos las librerias que usaremos para nuestro diagrama:\n",
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Para hacer el Diagrama, es necesario organizar los datos que contienen los distintos archivos de forma que se pueda acceder a la información sobre la temperatura, luminosidad, etc."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Definimos 4 variables que son los archivos donde se encuentran los datos a graficar.\n",
+ "ms_file = 'ms.csv'\n",
+ "sg_file = 'supergiants.txt'\n",
+ "g_file = 'giants.txt'\n",
+ "d_file = 'dwarfs.csv'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Vamos a definir una funcion que reciba en la entrada los archivos donde está la informacon de las estrellas y entregue \n",
+ "## un arreglo listo para ser usado\n",
+ "def file_to_data(archivo):\n",
+ " r = False\n",
+ " if archivo == sg_file:\n",
+ " sg_array = np.loadtxt(archivo , skiprows = 1)\n",
+ " # NumPy convierte cada fila de datos en una mini-lista cuyos objetos constituyentes so números flotantes.\n",
+ " r = 'txt'\n",
+ " elif archivo == g_file:\n",
+ " g_array = np.loadtxt(archivo , skiprows = 1)\n",
+ " r = 'txt'\n",
+ " elif archivo == ms_file:\n",
+ " ms = open(archivo)\n",
+ " r = 'cvs'\n",
+ " raw_datalist_0 = ms.readlines()\n",
+ " \n",
+ " # Vamos a escribir una ruina que sea capaz de identificar los caracteres que no se necesitan en la lista\n",
+ " ## \"raw_datalist_0\" y los elimine. Luego convertirá cada elemento de la lista (cadena con 3 datos diferentes), \n",
+ " ### en una lista más pequeña con objetos tipo cadenas. Finalmente las cadenas se convertiran en objetos flotantes\n",
+ " #### que podrán ser graficados utilizando matplitlib. \n",
+ " \n",
+ " # raw_datalist_1 = [] # Lista vacÃa innecesaria \n",
+ "\n",
+ " raw_datalist_0.pop(0)\n",
+ " \n",
+ " raw_datalist_1 = [] # Aquà vamos a eliminar el salto de linea, el que está al final de cada cadena. \n",
+ "\n",
+ " for n_s1 in range(0, len(raw_datalist_0) ,1):\n",
+ " data = raw_datalist_0[n_s1].rstrip('\\n')\n",
+ " raw_datalist_1.append(data) # Aquà ya tenemos la lista con los datos sin el último caracter de nueva linea.\n",
+ " \n",
+ " \n",
+ " # Tenemos que separar cada cadena de \"raw_datalist_1\" en una lista donde los elementos serán los caracteres\n",
+ " ## que no sean comas. Esto lo vamos a hacer usando spit()\n",
+ "\n",
+ " ms_datalist = []\n",
+ " for n_s2 in range(0, len(raw_datalist_1) ,1):\n",
+ " data_list = raw_datalist_1[n_s2].split(',')\n",
+ " ms_datalist.append(data_list)\n",
+ " # Lo logramos, cada elemento sale como una mini-lista\n",
+ " \n",
+ " # Ahora tenemos que hacer que los elementos de esta mini-lista sean caracteres numéricos que podamos \n",
+ " ## organizar y graficar, es decir, sean caracteres flotantes\n",
+ " for n_s3 in range(0,3,1):\n",
+ " data_fl = float(ms_datalist[n_s2][n_s3])\n",
+ " ms_datalist[n_s2][n_s3] = data_fl\n",
+ " ms_array = np.array(ms_datalist)\n",
+ " # Nuestra salida son los datos en el formato apropiado\n",
+ " \n",
+ " # Este caso se sigue la misa lógica anterior, esta vez no colocamos comentarios.\n",
+ " elif archivo == d_file:\n",
+ " d = open(archivo)\n",
+ " r = 'cvs'\n",
+ " raw_datalist_0 = d.readlines()\n",
+ " raw_datalist_0.pop(0)\n",
+ " raw_datalist_1 = []\n",
+ "\n",
+ " for n_s1 in range(0, len(raw_datalist_0) ,1):\n",
+ " data = raw_datalist_0[n_s1].rstrip('\\n')\n",
+ " raw_datalist_1.append(data)\n",
+ " \n",
+ " d_datalist = []\n",
+ " for n_s2 in range(0, len(raw_datalist_1) ,1):\n",
+ " data_list = raw_datalist_1[n_s2].split(',')\n",
+ " d_datalist.append(data_list)\n",
+ " for n_s3 in range(0,3,1):\n",
+ " data_fl = float(d_datalist[n_s2][n_s3])\n",
+ " d_datalist[n_s2][n_s3] = data_fl\n",
+ " d_array = np.array(d_datalist)\n",
+ " \n",
+ " else:\n",
+ " r = False\n",
+ " \n",
+ " #Finalmente podemos presentar una salida acorde con el valor de entrada\n",
+ " if r == 'txt':\n",
+ " if archivo == sg_file:\n",
+ " return sg_array\n",
+ " elif archivo == g_file:\n",
+ " return g_array\n",
+ " elif r == 'cvs':\n",
+ " if archivo == d_file:\n",
+ " return d_array\n",
+ " elif archivo == ms_file:\n",
+ " return ms_array\n",
+ " else:\n",
+ " return 'Error'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Una vez que tenemos nuestro arreglo de datos, todos en el formato apropiado (float), debemos hacer la rutina que reciba un arreglo de datos y devuelva el arreglo de datos graficado en el formato de los diagramas H-R."
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {},
+ "outputs": [],
+ "source": [
+ "# Vamos a definir una rutina que reciba los datos ordenados de la celda anterior, salida de la función file_to_data(). \n",
+ "## La idea es que a la salida se obtenga un arreglo de puntos (Temperatura, Luminosidad) que es graficado como un diagrama H-R.\n",
+ "### Esta función que vamos a definir tendrá como entrada cuatro arreglos e imprimirá el Diagrama H-R.\n",
+ "\n",
+ "def datas_to_plots(data_array1,data_array2,data_array3,data_array4):\n",
+ " v = True\n",
+ " if type(data_array1) == np.ndarray and type(data_array2) == np.ndarray and type(data_array3) == np.ndarray and type(data_array4) == np.ndarray:\n",
+ " print('\\nYa vienen los gráficos')\n",
+ "\n",
+ " HR_datalist1 = []\n",
+ " HR_datalist2 = []\n",
+ " HR_datalist3 = []\n",
+ " HR_datalist4 = []\n",
+ " HR_points1 = []\n",
+ " HR_points2 = []\n",
+ " HR_points3 = []\n",
+ " HR_points4 = []\n",
+ "\n",
+ " for l in range(0,len(data_array1),1):\n",
+ " HR_points1 = [data_array1[l][1],data_array1[l][0]]\n",
+ " HR_datalist1.append(HR_points1)\n",
+ " HR_plot_data1 = np.array(HR_datalist1)\n",
+ " \n",
+ " for l in range(0,len(data_array2),1):\n",
+ " HR_points2 = [data_array2[l][1],data_array2[l][0]]\n",
+ " HR_datalist2.append(HR_points2)\n",
+ " HR_plot_data2 = np.array(HR_datalist2)\n",
+ " \n",
+ " for l in range(0,len(data_array3),1):\n",
+ " HR_points3 = [data_array3[l][1],data_array3[l][0]]\n",
+ " HR_datalist3.append(HR_points3)\n",
+ " HR_plot_data3 = np.array(HR_datalist3)\n",
+ " \n",
+ " for l in range(0,len(data_array4),1):\n",
+ " HR_points4 = [data_array4[l][1],data_array4[l][0]]\n",
+ " HR_datalist4.append(HR_points4)\n",
+ " HR_plot_data4 = np.array(HR_datalist4) \n",
+ " \n",
+ " #Datos para el grafico:\n",
+ " T1,L1 = HR_plot_data1.T\n",
+ " T2,L2 = HR_plot_data2.T\n",
+ " T3,L3 = HR_plot_data3.T\n",
+ " T4,L4 = HR_plot_data4.T\n",
+ " plt.figure(figsize=(8,6))\n",
+ " plt.xlabel('Temperatura (K)') \n",
+ " plt.ylabel('Luminosidad (luminosidades solares)')\n",
+ " plt.title('Diagrama Hertzsprung-Russell.')\n",
+ " plt.scatter(T1,L1, color='green', marker='*', label= 'Secuencia Principal')\n",
+ " plt.scatter(T2,L2 , color='red', marker='p' , label = 'Super Gigantes Rojas')\n",
+ " plt.scatter(T3,L3 , color='orange', marker='d', label = 'Gigantes Rojas')\n",
+ " plt.scatter(T4,L4 , color='blue', marker='s' , label = 'Enanas Blancas')\n",
+ " plt.yscale('log')\n",
+ " plt.axis([max(T4+T4/5), min(T1), min(L4), max(L2+L2/5)])\n",
+ " plt.legend()\n",
+ " else:\n",
+ " print('No se puede graficar.')\n",
+ " v = False\n",
+ " if v == True:\n",
+ " return plt.show\n",
+ " else:\n",
+ " return 'Error'"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "Ya tenemos definidas las funciones que son capaces de graficar un arreglo de datos como un diagrama H-R. Ahora vamos a escribir una rutina que pueda ejecutar todo de manera automatica en una sola celda:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {},
+ "outputs": [
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Escriba el nombre de sus archivos con los datos. \n",
+ "Aquà tiene los nombres \n",
+ "Secuencia principal: ms.csv \n",
+ "Super Gigantes: supergiants.txt \n",
+ "Gigantes Rojas: giants.txt \n",
+ "Enanas: dwarfs.csv\n",
+ "Ingrese el nombre de su archivo con los datos de la secuencia principal \n",
+ "ms.csv\n",
+ "Ingrese el nombre de su archivo con los datos de las super gigantes rojas \n",
+ "supergiants.txt\n",
+ "Ingrese el nombre de su archivo con los datos de las gigantes rojas \n",
+ "giants.txt\n",
+ "Ingrese el nombre de su archivo con los datos de las enanas blancas \n",
+ "dwarfs.csv\n",
+ "\n",
+ "Ya vienen los gráficos\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "<function matplotlib.pyplot.show(*args, **kw)>"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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\n",
+ "text/plain": [
+ "<Figure size 576x432 with 1 Axes>"
+ ]
+ },
+ "metadata": {
+ "needs_background": "light"
+ },
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "print('Escriba el nombre de sus archivos con los datos. \\nAquà tiene los nombres \\nSecuencia principal: ms.csv \\nSuper Gigantes: supergiants.txt \\nGigantes Rojas: giants.txt \\nEnanas: dwarfs.csv')\n",
+ "data_array1 = file_to_data(input('Ingrese el nombre de su archivo con los datos de la secuencia principal \\n'))\n",
+ "data_array2 = file_to_data(input('Ingrese el nombre de su archivo con los datos de las super gigantes rojas \\n'))\n",
+ "data_array3 = file_to_data(input('Ingrese el nombre de su archivo con los datos de las gigantes rojas \\n'))\n",
+ "data_array4 = file_to_data(input('Ingrese el nombre de su archivo con los datos de las enanas blancas \\n'))\n",
+ "#data_array = file_to_data(ms_file)\n",
+ "datas_to_plots(data_array1,data_array2,data_array3,data_array4)"
+ ]
+ },
+ {
+ "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.7.4"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}