Taller_11_SciPy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyNFVSqBjJuDVMVeNT/VMhUv",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/gabrielawad/talleresGoogleColab/blob/main/Taller_11_SciPy.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## «El pasado no puede usarse para predecir el futuro».\n",
        "### [Nassim Nicholas Taleb](https://es.wikipedia.org/wiki/Nassim_Taleb)"
      ],
      "metadata": {
        "id": "PQD9h2SzQfQb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Taller 11 SciPy (Scientific Python)\n",
        "\n",
        "En este taller aprenderá los conceptos **básicos** relativos a la librería SciPy diseñada para resolver problemas de **matemáticas**, **ciencias** e **ingeniería**.\n",
        "\n",
        "SciPy  **no es una librería nativa** de Python por lo que **requiere ser instalada antes de ser invocada**. Sin embargo, esta librería sí está preinstalada en Google Colaboratory por lo que basta invocarla para poder usar sus funcionalidades.\n",
        "\n",
        "Puede consultar mayor información en: [SciPy](https://scipy.org/).\n",
        "\n",
        "**Importante**: SciPy es una librería de código abierto que tiene como código *base* a NumPy."
      ],
      "metadata": {
        "id": "jyM8H07mQgZX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## ¿Quiere contribuir?\n",
        "\n",
        "SciPy está abierto para muchos tipos de colaboración. En el enlace [SciPy GitHub](https://github.com/scipy/scipy) encontrará muchas de las posibilidades para aportar en el desarrollo y mantenimiento de esta librería."
      ],
      "metadata": {
        "id": "VtHU4vUgzMzh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Referencias\n",
        "\n",
        "Este taller se basa en información e ideas recopiladas de las siguientes fuentes:\n",
        "\n",
        "* [SciPy User Guide](https://docs.scipy.org/doc/scipy/tutorial/index.html#user-guide)\n",
        "* [SciPy Introduction](https://www.w3schools.com/python/scipy/scipy_intro.php)\n",
        "* [SciPy Tutorial](https://www.tutorialspoint.com/scipy/index.htm)\n",
        "* [SciPy Tutorial for Beginners | Overview of SciPy library](https://www.mygreatlearning.com/blog/scipy-tutorial/)\n",
        "* [Tutorial de SciPy](https://interactivechaos.com/es/manual/tutorial-de-scipy/tutorial-de-scipy)\n",
        "* [SciPy in Python Tutorial: What is, Library, Function & Examples](https://www.guru99.com/scipy-tutorial.html)\n",
        "* [Python SciPy Tutorial](https://www.javatpoint.com/python-scipy)\n",
        "* [What is SciPy in Python: Learn with an Example](https://intellipaat.com/blog/tutorial/python-tutorial/python-scipy/)\n",
        "* [1: Tutorial de Scipy](https://espanol.libretexts.org/Fisica/F%C3%ADsica_Matem%C3%A1tica_y_Pedagog%C3%ADa/F%C3%ADsica_Computacional_(Chong)/01%3A_Tutorial_de_Scipy)\n",
        "* [Introduction to SciPy Tutorial](https://www.projectpro.io/data-science-in-python-tutorial/scipy-introduction-tutorial)\n",
        "* [SciPy Tutorial: What is Python SciPy and How to use it?](https://www.edureka.co/blog/scipy-tutorial/)\n",
        "* [Python SciPy Tutorial - A Guide for Beginners](https://phoenixnap.com/kb/scipy-tutorial)"
      ],
      "metadata": {
        "id": "MIQs9kVNRd5P"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Constantes\n",
        "\n",
        "La librería SciPy contiene constantes que se utilizan en matemáticas, ciencias e ingeniería para cálculos de masa, ángulos, tiempo, longitud, área, volumen, presión, velocidad, temperatura, energía, potencia y fuerza.\n",
        "\n",
        "Las constantes en cada categoría se definen a partir de un patrón. Algunos de los patrones son:\n",
        "* masa: gramo\n",
        "* ángulos: radianes\n",
        "* tiempo: segundos\n",
        "* longitud: metro\n",
        "* área: metro cuadrado\n",
        "* volumen: metro cúbico\n",
        "* presión: pascals\n",
        "* velocidad: metro por segundo\n",
        "* temperatura: Kelvin\n",
        "* energía: joules\n",
        "* potencia: watts\n",
        "* fuerza: newtons\n"
      ],
      "metadata": {
        "id": "3JJHlX5NXk3b"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "Kr7UzmunQZK4"
      },
      "outputs": [],
      "source": [
        "# Importar las librerías requeridas\n",
        "import scipy.constants as constants\n",
        "\n",
        "# Mostrar el directorio de todas las constantes contenidas en ScyPy\n",
        "print(f\"Las constantes en el directorio de SciPy son: \\n {dir(constants)}\\n\")\n",
        "\n",
        "# Conocer la cantidad de constantes\n",
        "print(f\"La cantidad de constantes en SciPy es: {len(dir(constants))} \\n\")\n",
        "\n",
        "# Imprimir el valor de una constante de SciPy\n",
        "print(f\"El valor de Avogadro en SciPy es: {constants.Avogadro} \\n\")\n",
        "print(f\"El valor de un kilogramo en SciPy es: {constants.kilo} \\n\")"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Algebra lineal\n",
        "\n",
        "SciPy resuelve ecuaciones simultáneas lineales por medio del módulo **linalg**.\n",
        "\n",
        "Resolver el sistema:\n",
        "\n",
        "4x + 2y + 5z = 100\n",
        "\n",
        "2x + 5y + z = 80\n",
        "\n",
        "3x + 3y + 8z = 60\n"
      ],
      "metadata": {
        "id": "HgDw3J6QN3Kz"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import scipy.linalg as linalg\n",
        "\n",
        "\n",
        "# Crear los arreglos con los coeficientes\n",
        "a = np.array([[4, 2, 5], [2, 5, 1], [3, 3, 8]])\n",
        "b = np.array([100, 80, 60])\n",
        "\n",
        "# Resolver el sistema de ecuaciones\n",
        "respuesta = linalg.solve(a, b)\n",
        "\n",
        "# Mostrar los resultados\n",
        "print (f\"El valor de x es: {respuesta[0]} \\n\")\n",
        "print (f\"El valor de y es: {respuesta[1]} \\n\")\n",
        "print (f\"El valor de z es: {respuesta[2]} \\n\")"
      ],
      "metadata": {
        "id": "_DZUgzauN67a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Estadística"
      ],
      "metadata": {
        "id": "UJ1kUHN8N7ZL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import scipy.stats as stats\n",
        "\n",
        "# Crear un arreglo de números aleatorios\n",
        "valores = np.random.normal(size=100)\n",
        "\n",
        "# Calcular los estadísticos del arreglo\n",
        "est_descript = stats.describe(valores)\n",
        "\n",
        "# Mostrar los estadísticos del arreglo\n",
        "print(f\"El número de observaciones del arreglo es: {est_descript[0]} \\n\")\n",
        "print(f\"El valor mínimo del arreglo es: {est_descript[1][0]} \\n\")\n",
        "print(f\"El valor máximo del arreglo es: {est_descript[1][1]} \\n\")\n",
        "print(f\"La media del arreglo es: {est_descript[2]} \\n\")\n",
        "print(f\"La varianza del arreglo es: {est_descript[3]} \\n\")\n",
        "print(f\"La skewness del arreglo es: {est_descript[4]} \\n\")\n",
        "print(f\"La kurtosis del arreglo es: {est_descript[5]} \\n\")"
      ],
      "metadata": {
        "id": "F8hg7VBaOBDQ"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Datos espaciales\n",
        "Los datos espaciales se refieren a datos que son representados en espacios geométricos. Ejemplo: plano cartesiano, coordenadas polares."
      ],
      "metadata": {
        "id": "dzXFhGixOXMp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Distancia euclideana"
      ],
      "metadata": {
        "id": "UyC4rr_HZdS7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import scipy.spatial.distance as dst\n",
        "\n",
        "# Crear los puntos con las coordenadas\n",
        "punto_01 = (1,0)\n",
        "punto_02 = (3,4)\n",
        "\n",
        "# Calcular la distancia euclideana\n",
        "dist_euclideana = dst.euclidean(punto_01, punto_02)\n",
        "\n",
        "# Mostrar los resultados\n",
        "print(f\"La distancia euclideana entre {punto_01} y {punto_02} \\\n",
        "es {dist_euclideana}\")"
      ],
      "metadata": {
        "id": "mHe91Nz8ObW5"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Distancia de Manhattan (cityblock distance)"
      ],
      "metadata": {
        "id": "s0_i9N1PZt9C"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import scipy.spatial.distance as dst\n",
        "\n",
        "# Crear los puntos con las coordenadas\n",
        "punto_01 = (1,0)\n",
        "punto_02 = (3,4)\n",
        "\n",
        "# Calcular la distancia de Manhattan\n",
        "dist_manhattan = dst.cityblock(punto_01, punto_02)\n",
        "\n",
        "# Mostrar los resultados\n",
        "print(f\"La distancia de Manhattan entre {punto_01} y {punto_02} \\\n",
        "es {dist_manhattan}\")"
      ],
      "metadata": {
        "id": "JQzgrKnIZ3e0"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Distancia de coseno\n",
        "\n",
        "Calcula la distancia de coseno entre dos arreglos unidimensionales ([distance.cosine](https://docs.scipy.org/doc/scipy/reference/generated/scipy.spatial.distance.cosine.html))También se le conoce como [similitud coseno](https://es.wikipedia.org/wiki/Similitud_coseno)."
      ],
      "metadata": {
        "id": "bK5rirqSZ38x"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import scipy.spatial.distance as dst\n",
        "\n",
        "# Crear los puntos con las coordenadas\n",
        "punto_01 = (1,0)\n",
        "punto_02 = (3,4)\n",
        "\n",
        "# Calcular la distancia de coseno\n",
        "dist_coseno = dst.cosine(punto_01, punto_02)\n",
        "\n",
        "# Mostrar la distancia de coseno\n",
        "print(f\"La distancia de coseno entre {punto_01} y {punto_02} es {dist_coseno}\")"
      ],
      "metadata": {
        "id": "QRGExnWRZ_oI"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Distancia de Hamming\n",
        "\n",
        "Mide la distancia entre secuencias binarias. Es la proporción en que **difieren** dos secuencias binarias."
      ],
      "metadata": {
        "id": "u3Qmid_5aH1i"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import scipy.spatial.distance as dst\n",
        "\n",
        "# Crear las secuencias\n",
        "#secuencia_01 = (1, 0)\n",
        "#secuencia_02 = (0, 1)\n",
        "#secuencia_02 = (1, 0)\n",
        "\n",
        "secuencia_01 = (True, True, True, True, True)\n",
        "secuencia_02 = (True, False, False, True, True)\n",
        "\n",
        "\n",
        "# Calcular la distancia de Hamming\n",
        "dist_hamming = dst.hamming(secuencia_01, secuencia_02)\n",
        "\n",
        "# Mostrar la distancia de Hamming\n",
        "print(f\"La distancia de Hamming entre {secuencia_01} y \\\n",
        "{secuencia_02} es {dist_hamming}\")"
      ],
      "metadata": {
        "id": "56VYpjaEaU9g"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Aplicaciones"
      ],
      "metadata": {
        "id": "8DUy3vIDXp2x"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Triangulación\n",
        "La triangulación es una técnica que consiste en dividir un polígono en múltiples tripangulos con el propósito de calcular el área del polígono.\n",
        "\n",
        "Una triangulación con puntos consiste en crear una superficie compuesta de triángulos en la cual todos los puntos dados están en al menos en uno de los vértices de cualquier triángulo que compone la superficie.\n",
        "\n",
        "Una de las técnicas más usadas es la [Triangulación de Delaunay](https://en.wikipedia.org/wiki/Delaunay_triangulation)."
      ],
      "metadata": {
        "id": "bznv5EQfXsR4"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy.spatial as spt\n",
        "\n",
        "# Crear un arreglo de NumPy con siete puntos\n",
        "puntos = np.array([[1, 5], [3, 4], [2, 3], [3, 0], [3, 2], [0, 2], [4, 1]])\n",
        "#puntos = np.array([[1, 5], [3, 4], [3, 0],  [0, 2], [4, 1]])\n",
        "\n",
        "\n",
        "# Descomponer el área en triángulos con el método de Delaunay\n",
        "triangulos = spt.Delaunay(puntos).simplices\n",
        "\n",
        "# Graficar los triángulos\n",
        "plt.triplot(puntos[:, 0], puntos[:, 1], triangulos)\n",
        "\n",
        "# Mostrar los vértices de los triángulos\n",
        "plt.scatter(puntos[:, 0], puntos[:, 1], color='r')\n",
        "\n",
        "# Mostrar el gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "0Wp8axDlXwMn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Casco convexo (convex hull)\n",
        "\n",
        "Un casco convexo es el polígono más pequeño que encierra todos los puntos dados."
      ],
      "metadata": {
        "id": "nBwEhsL8WPiM"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# Importar las librerías requeridas\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "import scipy.spatial as spt\n",
        "\n",
        "# Crear un arreglo de NumPy con siete puntos\n",
        "puntos = np.array([[1, 5], [3, 4], [2, 3], [3, 0], [3, 2], [0, 2], [4, 1]])\n",
        "\n",
        "# Descomponer el área en triángulos con el método de Delaunay\n",
        "casco = spt.ConvexHull(puntos)\n",
        "puntos_casco =casco.simplices\n",
        "\n",
        "# Graficar el casco convexo\n",
        "for s in puntos_casco:\n",
        "  plt.plot(puntos[s, 0], puntos[s, 1], 'k-')\n",
        "\n",
        "# Mostrar los puntos originales\n",
        "plt.scatter(puntos[:, 0], puntos[:, 1], color='r')\n",
        "\n",
        "# Mostrar el gráfico\n",
        "plt.show()"
      ],
      "metadata": {
        "id": "9XKuuJDZWTYE"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Ejercicios"
      ],
      "metadata": {
        "id": "jrIwv7b7Xw2r"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 00\n",
        "Calcule la distancia euclideana para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link).\n",
        "Luego indique el promedio de las distancias, la distancia mínima y la distancia máxima entre dos puntos.\n",
        "Muestre el par de coordenadas cuya distancia es mínima y el par de coordenadas cuya distancia es mínima."
      ],
      "metadata": {
        "id": "MsCFFuuRXzIz"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "RUmNz0RHX2tr"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 01\n",
        "Calcule la distancia de Manhattan para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link).\n",
        "Luego indique el promedio de las distancias, la distancia mínima y la distancia máxima entre dos puntos.\n",
        "Muestre el par de coordenadas cuya distancia es mínima y el par de coordenadas cuya distancia es mínima."
      ],
      "metadata": {
        "id": "aonNcsUAziUn"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "irin-tPgzqKP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 02\n",
        "Calcule la distancia de coseno para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link).\n",
        "Luego indique el promedio de las distancias, la distancia mínima y la distancia máxima entre dos puntos.\n",
        "Muestre el par de coordenadas cuya distancia es mínima y el par de coordenadas cuya distancia es mínima."
      ],
      "metadata": {
        "id": "R1E8ATXLzq41"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "vsdpZ6OXzzO6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 03\n",
        "Aplique la [Triangulación de Delaunay](https://en.wikipedia.org/wiki/Delaunay_triangulation) para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link)."
      ],
      "metadata": {
        "id": "gotzMCVfz2AC"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "MyNz2Vsnz8Yn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 04\n",
        "Calcule el casco convexo para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link)."
      ],
      "metadata": {
        "id": "fHQd0FlZ0PaX"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "g2l7UHRl0d2K"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 05\n",
        "Calcule la sumatoria de mínimos cuadrados para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link)."
      ],
      "metadata": {
        "id": "tYYibL530Y74"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "d4qnmVT00kAt"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## 06\n",
        "Calcule el agrupamiento (*cluster*) de nivel tres para los puntos que se encuentran en el archivo [distancias.txt](https://drive.google.com/file/d/1r0UcBXjhjXnGc1bz7d1XeXb7jRg6SP6_/view?usp=share_link)."
      ],
      "metadata": {
        "id": "mKJAglKG0kkM"
      }
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "kjpNpMlk0uIb"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}