{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Fundamentos de Julia"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Es un lenguaje de programación Julia dinámica de alto nivel y alto rendimiento para computación científica. Proporciona un compilador sofisticado, ejecución paralela distribuida, precisión numérica y una extensa biblioteca de funciones matemáticas. Su rendimiento es superior en la mayoría de los casos que otros lenguajes de programación usados para el análisis de datos como Python, R o Matlab.\n",
    "\n",
    "* [Puedes consultar las pruebas de rendimiento](https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/julia-python3.html)\n",
    "\n",
    "* [Manual OFICIAL completo de Julia](https://raw.githubusercontent.com/JuliaLang/docs.julialang.org/assets/julia-1.5.3.pdf)\n",
    "\n",
    "* [Think Julia: How to Think Like a Computer Scientist](https://cidamo.com.br/JuliaIntroBR.jl/deploy/index.html)\n",
    "\n",
    "* [Data Science Tutorials in Julia](https://alan-turing-institute.github.io/DataScienceTutorials.jl/)\n",
    "\n",
    "Julia fue lanzado originalmente en 2012 por Alan Edelman, Stefan Karpinski, Jeff Bezanson y Viral Shah. Es un lenguaje de programación de código abierto y gratuito. La elección de un lenguaje de programación siempre es subjetiva. Las siguientes características de Julia son decisivas:\n",
    "\n",
    "* Julia se desarrolla como un lenguaje de programación de alto rendimiento.\n",
    "* Julia utiliza el envío múltiple, lo que permite al programador elegir entre diferentes patrones de programación adaptados a la aplicación.\n",
    "* Julia es un lenguaje escrito dinámicamente que se puede usar fácilmente de forma interactiva.\n",
    "* Julia tiene una buena sintaxis de alto nivel que es fácil de aprender.\n",
    "* Julia es un lenguaje de programación escrito opcionalmente cuyos tipos de datos (definidos por el usuario) hacen que el código sea más claro y robusto.\n",
    "* Julia tiene una biblioteca estándar extendida y numerosos paquetes de terceros están disponibles.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instalación\n",
    "\n",
    "1. Instalar Anaconda con JupyterLab. \n",
    "2. Descargar la correspondiente versión (current stable release) para su sistema operativo. [Página de Descargas de Julia](https://julialang.org/downloads/)\n",
    "3. Agregar a las variables de entorno la carpeta \"Julia x.x.x\\bin\" donde Julia ha sido Instalado, x.x.x es la versión que tenga instalada. \n",
    "4. Abrir una terminal y escribir el comando ```julia```. Esto inicia Juila y a continuación aparece la línea de comandos ```julia>```\n",
    "5. Para vincular Julia con Jupyter se requiere instalar el paquete ```IJulia```, en la línea de comandos de Julia escribimos ], esto habilitará la línea de comandos para instalar paquetes ```pkg>```. Entonces, en esta línea de comandos escribimos ```add IJulia``` y presionamos enter. (Este proceso que tarda entre 5 y 10 minutos, por favor sea paciente, el proceso ha finalizado cuando se muestra en consola ```Building IJulia``` y se presiona enter). Una vez finalizada la instalación, presionar ```ctrl+c``` para volver a la línea de comandos de Julia.\n",
    "6. Para ejecutar un libro, ejecutar en la línea de comandos de Julia ```using IJulia``` la primera vez tarda al rededor de un minuto.\n",
    "7. Finalmente, en la linea de comandos escriba ```jupyterlab()``` para ejecutar el cuaderno. La primera vez se pide ```install Jupyter via Conda, y/n?``` responder con ```y``` y presionar enter.\n",
    "8. Una vez finalizada la instalación, se abre automáticamente el explorador con una ventana del JupyterLab. Dentro de este se pueden crear cuadernos directamente para Julia.\n",
    "9. A cotinuación, seguiremos trabajando en Jupyter con Julia.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Julia Version 1.5.3\n",
      "Commit 788b2c77c1 (2020-11-09 13:37 UTC)\n",
      "Platform Info:\n",
      "  OS: Windows (x86_64-w64-mingw32)\n",
      "  CPU: Intel(R) Core(TM) i5-8265U CPU @ 1.60GHz\n",
      "  WORD_SIZE: 64\n",
      "  LIBM: libopenlibm\n",
      "  LLVM: libLLVM-9.0.1 (ORCJIT, skylake)\n"
     ]
    }
   ],
   "source": [
    "# verificamos la instalación\n",
    "versioninfo()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de Datos\n",
    "\n",
    "[Consultar Acá](https://en.wikibooks.org/wiki/Introducing_Julia/Types#/media/File:Julia-number-type-hierarchy.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![imagen.png](https://upload.wikimedia.org/wikipedia/commons/thumb/d/d9/Julia-number-type-hierarchy.svg/1920px-Julia-number-type-hierarchy.svg.png)\n",
    "\n",
    "## Números Enteros y Reales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Int64\n",
      "Número entero en notación Hexadecimal (Base 16) 0x22: 34\n",
      "UInt8\n",
      "Int64\n",
      "Número entero en notación Hexadecimal 0x222: 546\n",
      "UInt16\n",
      "Int64\n",
      "Número entero en notación Hexadecimal: 7e4\n",
      "Suma de Enteros: 2021\n",
      "Tipo Real\n",
      "Float64\n"
     ]
    }
   ],
   "source": [
    "# Números Enteros\n",
    "println(typeof(200000))\n",
    "\n",
    "println(\"Número entero en notación Hexadecimal (Base 16) 0x22: $(0x22)\")\n",
    "println(typeof(0x22)) # de una vez se asigna el tipo 64 sin signo\n",
    "println(typeof(34)) # de una vez se asigna el tipo 64\n",
    "\n",
    "println(\"Número entero en notación Hexadecimal 0x222: $(0x222)\")\n",
    "println(typeof(0x222))\n",
    "println(typeof(546))\n",
    "\n",
    "aHex = string(2020, base = 16)\n",
    "println(\"Número entero en notación Hexadecimal: $(aHex)\")\n",
    "suma = 0x7e4 + 1\n",
    "println(\"Suma de Enteros: $(suma)\")\n",
    "\n",
    "#Recomendado https://www.binaryhexconverter.com/hex-to-decimal-converter\n",
    "\n",
    "# Numeros reales o flotantes\n",
    "println(\"Tipo Real\")\n",
    "println(typeof(3455.23))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Números Complejos y Racionales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Soy complejo 30 + 3im\n",
      "Soy complejo 70 + 5im\n",
      "Complex{Int64}\n",
      "Soy racional 3//4\n",
      "Rational{Int64}\n",
      "Soy real 0.75\n",
      "Float64\n"
     ]
    }
   ],
   "source": [
    "complejo = 30 + 3im\n",
    "println(\"Soy complejo $(complejo)\")\n",
    "complejo = complejo + 40 + 2im\n",
    "println(\"Soy complejo $(complejo)\")\n",
    "println(typeof(complejo))\n",
    "\n",
    "racional = 9//12\n",
    "println(\"Soy racional $(racional)\")\n",
    "println(typeof(racional))\n",
    "\n",
    "real = 9/12\n",
    "println(\"Soy real $(real)\")\n",
    "println(typeof(real))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos de datos personalizados: Estructuras\n",
    "\n",
    "[Aquí para más info](https://docs.julialang.org/en/v1/manual/types/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Persona(\"Bartolomeo\", \"Av. Siempre Viva 2343\", 8, 20.1223)\n",
      "Tipo de dato de la variable: Persona\n",
      "Tipo de dato de la variable: Persona\n",
      "Direccion del estudiante: Av. Siempre Viva 2343\n",
      "Atributos de la Persona: (:nombre, :direccion, :edad, :imc)\n",
      "Atributos del estudiante: (:nombre, :direccion, :edad, :imc)\n"
     ]
    }
   ],
   "source": [
    "struct Persona\n",
    "    nombre\n",
    "    direccion::String\n",
    "    edad::Int\n",
    "    imc::Float64\n",
    "end\n",
    "\n",
    "estudiante = Persona(\"Bartolomeo\",\"Av. Siempre Viva 2343\", 8, 20.1223)\n",
    "println(estudiante)\n",
    "println(\"Tipo de dato de la variable: \" * string(typeof(estudiante)))\n",
    "println(\"Tipo de dato de la variable: $(string(typeof(estudiante)))\")\n",
    "println(\"Direccion del estudiante: \" * estudiante.direccion)\n",
    "println(\"Atributos de la Persona: \" * string(fieldnames(Persona)))\n",
    "println(\"Atributos del estudiante: \" * string(fieldnames(typeof(estudiante))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre: Natalia Es Remitido: false\n",
      "Edad: 26.0 Cantidad Hijos: 0\n"
     ]
    }
   ],
   "source": [
    "struct Paciente\n",
    "    nombre::String\n",
    "    remitido::Bool\n",
    "    edad::Float64\n",
    "    cantidadHijos::Int\n",
    "end\n",
    "\n",
    "function describir(p::Paciente)\n",
    "    println(\"Nombre: \", p.nombre, \" Es Remitido: \", p.remitido)\n",
    "    println(\"Edad: \", p.edad, \" Cantidad Hijos: \", p.cantidadHijos)\n",
    "end\n",
    "\n",
    "\n",
    "nata = Paciente(\"Natalia\",0,26,0)\n",
    "\n",
    "describir(nata)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tipos de datos personalizados: Tipos Abstractos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Array{Any,1}:\n",
       " Gato\n",
       " Jaguar\n",
       " Leon\n",
       " Pantera"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abstract type Felino end\n",
    "\n",
    "mutable struct Jaguar <: Felino \n",
    "end\n",
    "\n",
    "mutable struct Leon <: Felino end\n",
    "mutable struct Pantera <: Felino end\n",
    "\n",
    "mutable struct Gato <: Felino\n",
    "    zona\n",
    "end\n",
    "\n",
    "subtypes(Felino)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gato\n",
      "Dibujos Animados\n",
      "Felino\n",
      "Felino\n"
     ]
    }
   ],
   "source": [
    "tom = Gato(\"Dibujos Animados\")\n",
    "println(typeof(tom))\n",
    "println(tom.zona)\n",
    "println(supertype(Gato))\n",
    "println(supertype(typeof(tom)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Enteros y Reales con Precisión Arbitraria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "BigInt\n",
      "BigFloat\n"
     ]
    }
   ],
   "source": [
    "enteroGrande = BigInt(5052785737795758503064406447721934417290878968063369478337)\n",
    "println(typeof(enteroGrande))\n",
    "\n",
    "flotanteGrande = BigFloat(3.14159265358979323846264338327950288419716939937510582097)\n",
    "println(typeof(flotanteGrande))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cálculos relativamente grandes\n",
    "\n",
    "### Consideraciones Básicas\n",
    "\n",
    "Lectura recomendada [las potencias de 2](https://en.wikipedia.org/wiki/Power_of_two)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 elevado a la 256 es: 0\n",
      "Int64\n",
      "Int64\n",
      "2 elevado a la 64 es: 0\n",
      "2 elevado a la 62 es: 4611686018427387904\n",
      "2 elevado a la 64 es: 18446744073709551616\n",
      "La cantidad de dígitos que se obtienen con 32 bits es: 10\n",
      "La cantidad de dígitos que se obtienen con 64 bits es: 20\n",
      "La cantidad de dígitos que se obtienen con 256 bits es: 78\n",
      "La cantidad de dígitos que se obtienen con 1024 bits es: 309\n"
     ]
    }
   ],
   "source": [
    "# Deseamos calcular 2 ^ 256\n",
    "println(\"2 elevado a la 256 es: $(2 ^ 256)\")\n",
    "\n",
    "#Lo anterior nos entrega un resultado muy sospechoso\n",
    "# veamos el tipo de datos de 2 y 256\n",
    "println(typeof(2))\n",
    "println(typeof(256))\n",
    "\n",
    "#Son enteros de 64 bits, esto significa que solo permiten\n",
    "# representar números hasta 2 ^ 64 bits\n",
    "println(\"2 elevado a la 64 es: $(2 ^ 64)\")\n",
    "\n",
    "# La operación continúa dando como resultado 0, dado que\n",
    "# el cero ocupa un bit y el signo otro bit,\n",
    "# lo máximo es hasta 2 ^ (64 - 2)\n",
    "println(\"2 elevado a la 62 es: $(2 ^ 62)\")\n",
    "\n",
    "#A partir de 64 bits se requiere usar el tipo de dato BigInt\n",
    "println(\"2 elevado a la 64 es: $(BigInt(2) ^ 64)\")\n",
    "\n",
    "# Una precisión de 32bits permite tener números de 10 digitos\n",
    "# Precisión de 10 Dígitos\n",
    "println(\"La cantidad de dígitos que se obtienen con 32 bits es: $(length(string(2^32)))\")\n",
    "\n",
    "#A partir de 64 bits se requiere usar el tipo de dato BigInt\n",
    "cantidadDigitos = length(string(BigInt(2)^64))\n",
    "println(\"La cantidad de dígitos que se obtienen con 64 bits es: $(cantidadDigitos)\")\n",
    "\n",
    "cantidadDigitos = length(string(BigInt(2)^256))\n",
    "println(\"La cantidad de dígitos que se obtienen con 256 bits es: $(cantidadDigitos)\")\n",
    "\n",
    "cantidadDigitos = length(string(BigInt(2)^1024))\n",
    "println(\"La cantidad de dígitos que se obtienen con 1024 bits es: $(cantidadDigitos)\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cambiando la precisión"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "π con una precisión de 256 bits: 3.141592653589793238462643383279502884197169399375105820974944592307816406286198\n",
      "π con una precisión de 1024 bits: 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067982148086513282306647093844609550582231725359408128481117450284102701938521105559644622948954930381964428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273724586997\n"
     ]
    }
   ],
   "source": [
    "# π con una precisión de 256 bits\n",
    "println(\"π con una precisión de 256 bits: $(BigFloat(0) + pi)\")\n",
    "\n",
    "# Pi con una precisión de 1024 bits, es decir, 309 cifras decimales\n",
    "setprecision(BigFloat, 1024) do\n",
    "    println(\"π con una precisión de 1024 bits: $(BigFloat(pi))\")\n",
    "end\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.5.3",
   "language": "julia",
   "name": "julia-1.5"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.5.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}