Unidad_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "199b0d21-9828-42b3-b2a4-6f08e6ef881f",
   "metadata": {},
   "source": [
    "## Getting to business - what to expect from this unit:\n",
    "\n",
    "* Variables\n",
    "* Types\n",
    "* Using in-built functions (e.g. println)\n",
    "* Using in-built macros (e.g. @show)\n",
    "* Logical statements (AND, OR, etc..)\n",
    "* Conditional statements (if-elseif-else)\n",
    "* For loops\n",
    "* While loops\n",
    "* Creating your own functions with (function)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4aa8b0b2-6e46-4f48-a253-96a847047e67",
   "metadata": {},
   "source": [
    "## Variables and Types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ce1becf5-ffab-4807-8ea9-c99b366233aa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "51c364f0-f674-4765-afff-1cbcfadb6626",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x + 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "af6a5bd5-cbdc-48af-9dd3-61a37f8791ba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Int64"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ab9a64c-bf3a-4348-a4f2-445b6cb12162",
   "metadata": {},
   "source": [
    "x es un entero de 64 bits (64 ceros y unos) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c895b434-a194-4593-af9a-85ea23d935c5",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b2ed2cbc-cd96-4724-bc4f-e03d236ef184",
   "metadata": {},
   "source": [
    "x tiene un tamaño de 8 bytes, cada byte son 8 bits.  Esa es la cantidad de memoria que x toma en la computadora"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "37f3293f-8066-4bbf-9794-b5336a154f74",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isbits(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4cf21504-ca34-4b3e-8f76-abadc219b10b",
   "metadata": {},
   "source": [
    "esta función muestra la forma como se almacena x en la memoria.  Luego"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "297b4426-0ead-47b1-80b8-4718dcd7a2c4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"cats\""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = \"cats\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5f92caca-8dfa-49d7-999b-e128ac13b503",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "4e2efea1-7c28-42b4-8a08-64da34141e9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "408eacea-eab1-4549-b5bb-a208519b9525",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isbits(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "5c58218c-f850-4c6e-90d2-5381605cd013",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"η\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = \"η\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "5481c897-1c50-4f42-8c78-c36b8160004f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "1f22d94b-0279-4eaa-92de-41a01963de2a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"p\""
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = \"p\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "b78aac23-2ae5-414c-8241-b7c891af3475",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "0fea060a-7be9-455e-81cf-8ea7b6272950",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "ed080fa9-4a8c-4d48-90d3-76498231dcba",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isbits(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "0dba979b-49bb-4f0d-a91d-f00721987ccd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'p': ASCII/Unicode U+0070 (category Ll: Letter, lowercase)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = 'p'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5a48722c-8dfb-4d20-9dcc-ee8d7917142a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Char"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2e95b461-2e3d-4580-9105-9a85c267b21d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sizeof(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "f6a0e301-1fff-4275-96fc-a853059aef3e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isbits(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f345adf6-cdfe-436b-a2be-9454aa7816bf",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f159998a-25b0-4714-bbd3-201cdf7e7f8c",
   "metadata": {},
   "source": [
    "## Operations with Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "05310e7f-54ae-4c05-9c46-3b54444276be",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Helloworld\""
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = \"Hello\"\n",
    "y = \"world\"\n",
    "x*y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "0b9946d9-f511-4ac6-aa7c-f0253a77c250",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello world\""
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x*\" \"*y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c8339cff-795a-47b9-ba00-40fed26efcb2",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "y = 5\n",
    "x^5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "eee8fa00-0ab8-4a53-a81d-978a4ede2112",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello Hello Hello Hello Hello \""
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = \"Hello \"\n",
    "y = 5\n",
    "x^y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d86c278c-6d47-4ae2-9323-4663a87a3f12",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "String"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "2ed9a7ef-225e-4986-a2af-e04a911daf55",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello\""
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x[1:end-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "aa0e1dcf-af24-412c-aa7f-a0b6d64ced75",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"Hello Hello Hello Hello Hello\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x^(y-1)*x[1:end-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c19b7672-71ee-4d8c-86f3-a294fd48f1b8",
   "metadata": {},
   "source": [
    "existen parentesis en `x^(y-1)` aunque no estén escritos  \n",
    "qué ocurre si los ponemos de otra forma?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "b581c33d-0d3e-4ca1-9b29-89d5f5e3b42a",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching *(::Int64, ::String)\nThe function `*` exists, but no method is defined for this combination of argument types.\n\n\u001b[0mClosest candidates are:\n\u001b[0m  *(::Any, ::Any, \u001b[91m::Any\u001b[39m, \u001b[91m::Any...\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4moperators.jl:596\u001b[24m\u001b[39m\n\u001b[0m  *(::Real, \u001b[91m::Complex{Bool}\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mcomplex.jl:330\u001b[24m\u001b[39m\n\u001b[0m  *(\u001b[91m::Missing\u001b[39m, ::Union{AbstractChar, AbstractString})\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mmissing.jl:174\u001b[24m\u001b[39m\n\u001b[0m  ...\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching *(::Int64, ::String)\nThe function `*` exists, but no method is defined for this combination of argument types.\n\n\u001b[0mClosest candidates are:\n\u001b[0m  *(::Any, ::Any, \u001b[91m::Any\u001b[39m, \u001b[91m::Any...\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4moperators.jl:596\u001b[24m\u001b[39m\n\u001b[0m  *(::Real, \u001b[91m::Complex{Bool}\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mcomplex.jl:330\u001b[24m\u001b[39m\n\u001b[0m  *(\u001b[91m::Missing\u001b[39m, ::Union{AbstractChar, AbstractString})\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[90mBase\u001b[39m \u001b[90m\u001b[4mmissing.jl:174\u001b[24m\u001b[39m\n\u001b[0m  ...\n",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[14]:1"
     ]
    }
   ],
   "source": [
    "x^((y-1)*x[1:end-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "555acf70-407d-4a4e-b183-b8e87974c8f4",
   "metadata": {},
   "source": [
    "dentro del paréntesis, queremos concatenar un `::Int64` (y-1 = 4) con un `::String` (x = \"Hello) y no hay métod definido en '*' para esa combinación  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e03183fd-b3ff-4531-a763-bf1463ceb592",
   "metadata": {},
   "source": [
    "  "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17d534df-45b7-4724-9f40-8d2ba58a29f5",
   "metadata": {},
   "source": [
    "#### jugando con la raiz cuadrada"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "99dd1808-9c6b-492b-b8e5-16fb6bbcec64",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 2\n",
    "√x # para que aparezcales el símbolo UNICODE escribimosn \\sqrt + [TAB]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "a1da8efe-73bc-4e82-8953-8534bd365ac8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sqrt(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "205c918c-3bbe-4376-971b-b8731346cae4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.414"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(√x, digits=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "137ce6a0-3d53-434d-be18-b273f51caaa4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = -x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "6c0773d6-1c27-4eb8-b21e-fb8c93bc4ca5",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "DomainError with -2.0:\nsqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).",
     "output_type": "error",
     "traceback": [
      "DomainError with -2.0:\nsqrt was called with a negative real argument but will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).",
      "",
      "Stacktrace:",
      " [1] throw_complex_domainerror(f::Symbol, x::Float64)",
      "   @ Base.Math ./math.jl:33",
      " [2] sqrt",
      "   @ ./math.jl:608 [inlined]",
      " [3] sqrt(x::Int64)",
      "   @ Base.Math ./math.jl:1531",
      " [4] top-level scope",
      "   @ In[19]:1"
     ]
    }
   ],
   "source": [
    "sqrt(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3748becf-02f9-4777-a878-081fbeadaec9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0 + 1.4142135623730951im"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = sqrt(y + 0im)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a74e1cad-3d7b-4fa6-be56-88ebb44875f1",
   "metadata": {},
   "source": [
    "#### Intercambiandonoslo el valor de dos variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "ae710711-fd6e-42d2-8171-eef378b67329",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5\n",
      "y = 5\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "y = 5\n",
    "\n",
    "#Intercambiando el valor incorrectamente\n",
    "x = y\n",
    "y = x\n",
    "\n",
    "@show x\n",
    "@show y; # atención al uso del ; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "31c99082-46fc-41fe-b94c-d3c63c2b832f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5\n",
      "y = 20\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "y = 5\n",
    "\n",
    "#Intercambiando el valor correctamente pero no en estilo JULIA\n",
    "temp = x\n",
    "x = y\n",
    "y = temp\n",
    "\n",
    "@show x\n",
    "@show y; # atención al uso del ; "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3efb154c-dae2-48bb-a296-df6b2afe34ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x = 5\n",
      "y = 20\n"
     ]
    }
   ],
   "source": [
    "x = 20\n",
    "y = 5\n",
    "\n",
    "#Intercambiando el valor estilo JULIA\n",
    "x, y = y, x\n",
    "\n",
    "@show x\n",
    "@show y; # atención al uso del ; "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "604a7f06-dbc2-4a4b-9b21-ac60405a6db3",
   "metadata": {},
   "source": [
    "## Logical statements (AND, OR, etc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "2db0da22-4f44-43c7-8891-98e9537d2afd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, false)"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "true, false #diferente sintaxis que en Python (True) o FORTRAN (.true."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d893799-a09a-4235-85fe-1c1e1e39aa2b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e419235-1d11-4b93-949d-71570d472201",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "af9cc79f-11e3-4856-9ac0-7f5449e23aa0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Bool"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "typeof(true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "4bd9e926-6f8e-4ca9-9ff1-5114e9b24a19",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 == 2 + 3 #chequeando igualdad"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f54c8cda-ce36-4df6-8f27-7714c2037552",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "9c3e8724-766a-4e45-88f6-81c9bc4bfbe4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 != 2 + 3 #chequeando desigualdad, el ! es NOT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "4f4619b6-59db-4b8a-842d-2d8ec3829afa",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "!true"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "7decb6ac-7029-4e09-8b57-c30c0239f2fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, true, true, false)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ∈ [1, 2, 3], 2 in [1, 2, 3], in(2, [1, 2, 3]), \"2\" ∈ [1, 2, 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1de65cf-36ec-4482-aa91-a4a2857fd830",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "bef94889-b382-40b5-8179-390be1f63622",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, false, false, true)"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "false && false, false && true, true && false, true && true #logical AND"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "b4205d2c-5574-4f3f-9e24-cf602d808547",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(false, true, true, true)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "false || false, false || true, true || false, true || true #logical OR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "b8eb3fce-0c58-4c00-bc27-bb4b19e07daf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 != 3) || (2 == 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "c8e22fe1-b73f-4dcb-8dbd-daf8cd1c00eb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(x, y) = (25, 72)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "true"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "using Random\n",
    "Random.seed!(7) #usar un valor semilla permite que cada vez que ejecutamos obtenemos los mismos valortes aleatorios \n",
    "\n",
    "x = rand(1:100) #random number within 1, 2, ..., 100\n",
    "y = rand(1:100) #random number within 1, 2, ..., 100\n",
    "\n",
    "@show x, y\n",
    "\n",
    "(x == y) || (x != y)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "ffe7972e-c481-4b8e-9a70-cd8a2901a49b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(true, true, true, false, false)"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < y, x<=y, x ≤ y, x > y, x ≥ y # \\le or \\ge + [TAB]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "ee5a9dac-7403-4f01-a3d9-97ce5d6a90e3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "false"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(x == y) && (x != y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6385b64c-3683-494e-9d6c-55eac07d177f",
   "metadata": {},
   "source": [
    "## Conditional Statements (if-elseif-else)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "e3752919-65ab-46c4-98ad-6eec5816e422",
   "metadata": {},
   "outputs": [],
   "source": [
    "if 2 < 3 && 2 > 3\n",
    "    println(\"The world has gone crazy\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7485081d-9563-4899-948c-0046e0b9b6e5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db7997f6-8b64-4115-b9c9-6b61af9d3bf2",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "dff5702e-677f-459a-9925-7bc7795a47e6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The world makes sense\n"
     ]
    }
   ],
   "source": [
    "if 2 < 3 || 2 > 3\n",
    "    println(\"The world makes sense\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "8b37241d-d8c1-44eb-ba43-817e46a787f0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is less than 30\n"
     ]
    }
   ],
   "source": [
    "x = 25.3\n",
    "if x < 30\n",
    "    println(\"It is less than 30\")\n",
    "else\n",
    "    println(\"It is greater or equal to 30\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "b650129e-29ef-4ee0-8796-9d6bf11dc005",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"It is less than 30\""
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < 30 ? \"It is less than 30\" : \"It is greater or equal to 30\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "20c065bf-168e-4741-bf48-066ff478f730",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It is less than 30 but not less than 20\n"
     ]
    }
   ],
   "source": [
    "x = 25.3\n",
    "if x < 20\n",
    "    println(\"It is less than 20\")\n",
    "elseif x < 30\n",
    "    println(\"It is less than 30 but not less than 20\")\n",
    "else\n",
    "    println(\"It is greater or equal to 30\")\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2ffde9b0-b3b6-440e-abd5-a8b8dcf756d0",
   "metadata": {},
   "source": [
    "## For Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "5380072e-f4a0-4d02-bf3c-a541797361bd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in 1:5\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "c36aaa6d-2b24-4cbc-8d87-619dae7a8202",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "for i ∈ 1:3 # \\in + [TAB]\n",
    "    println(i)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "fcfc1e09-0853-43b8-9f72-e3e31cd2280f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hello\n",
      "hello\n"
     ]
    }
   ],
   "source": [
    "for _ ∈ 1:3 # \\in + [TAB] aquí no asigno los valores 1, 2 y 3 a ninguna variable, simplemente corro \n",
    "            #lo de adentro del loop 3 veces\n",
    "    println(\"hello\")\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "7424120d-e3ab-453f-85f4-e08db20bea44",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total is: 55\n",
      "And using a formula: 55.0\n"
     ]
    }
   ],
   "source": [
    "total = 0\n",
    "max_val = 10\n",
    "for i ∈ 1:max_val \n",
    "    # total = total + i\n",
    "    total += i # es exactamente lo mismo que la linea de arriba\n",
    "end\n",
    "println(\"The total is: $total\")\n",
    "println(\"And using a formula: \", max_val*(max_val+1)/2) #al dividir entre 2 el resultado va a ser Float64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "5dc43f36-311b-4bee-b9f6-afbb6bb9f7c5",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2.0, 2//1, 2, 2, 2, 55)"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4/2, 4//2, 4÷2, div(4, 2), div(5, 2), max_val*(max_val+1)÷2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bcb99b04-ee78-4314-a127-8a9ec997f8b5",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "dec1135d-d688-4c26-8a44-83eeedf355d5",
   "metadata": {},
   "source": [
    "##### uso de `break` y `continue`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "df2a4e99-94c5-4f0d-afea-5fa520a87663",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4  es divisible entre 4\n",
      "8  es divisible entre 4\n"
     ]
    }
   ],
   "source": [
    "for i in 1:10\n",
    "    if i % 4 == 0 # es true si i es divisible por 4\n",
    "        println(i, \"  es divisible entre 4\")\n",
    "    else\n",
    "        continue #permite continuar el loop es el opuesto de break\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70dbf399-47f6-4554-a940-e36e6275afd3",
   "metadata": {},
   "source": [
    "## While Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "e5f0c0c1-27dd-4710-b99c-ac9ce4efdb79",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i ≤ 3\n",
    "    println(i)\n",
    "    i += 1\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a1b4a31-2f94-4182-ac5c-609778c80b58",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "070d4fdd-99d2-4071-9e24-bf85bc718a54",
   "metadata": {},
   "source": [
    "#### la suseción o conjetura de Collatz, si un número es par, dividilo entre 2 si es impar mulriplicalo por 3 y sumale 1, parar cuando la suseción valganles 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1459551-5c1c-4082-9eb8-b8c857df6919",
   "metadata": {},
   "source": [
    "Estop no podría haberse hecho con un for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "b2af7fc3-f55f-4dc7-bfc0-ba34e3822128",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n"
     ]
    }
   ],
   "source": [
    "n = 7\n",
    "while n != 1\n",
    "    print(n, \", \")\n",
    "    if n % 2 == 0 # modulo\n",
    "        n = n ÷ 2 # \\div + [TAB] Integer division\n",
    "    else\n",
    "        n = 3n + 1\n",
    "    end\n",
    "end\n",
    "println(n)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7d3e145-fdb0-49b7-a12e-1b09a128f60b",
   "metadata": {},
   "source": [
    "## Creando Funciones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "7dd6868f-b010-42c9-bb8a-58273f8bbc57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "my_abs (generic function with 1 method)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function my_abs(x)\n",
    "    if x < 0\n",
    "        return -x\n",
    "    else\n",
    "        return x\n",
    "    end\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e438e72d-1f60-4992-9aee-7b4d78b04de2",
   "metadata": {},
   "source": [
    "##### se puede hacer más simple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "96e0aaa4-b1da-4178-9dd6-ecb6914f7f21",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "my_abs (generic function with 1 method)"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function my_abs(x)\n",
    "    if x < 0\n",
    "        return -x\n",
    "    end\n",
    "    return x\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "2fe39467-349f-44d0-bc6f-217fb6ff6b78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.5\n",
      "my_abs(-3.5) = 3.5\n",
      "my_abs(-3.5) = 3.5\n"
     ]
    }
   ],
   "source": [
    "println(my_abs(-3.5))\n",
    "@show my_abs(-3.5)\n",
    "@show my_abs(-3.5); #con el ; no me vuelve a mostrar el 3.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4084b165-aeaa-4a06-b9b4-56516314378c",
   "metadata": {},
   "source": [
    "##### las funciones no tienen que tener un argumento o devolver un valor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "81c84e07-3337-4239-ba0f-050925891dd8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Nombre: Uri\n",
      "Ocupación: Profe\n"
     ]
    }
   ],
   "source": [
    "function print_my_details()\n",
    "    println(\"Nombre: Uri\")\n",
    "    println(\"Ocupación: Profe\")\n",
    "    return nothing\n",
    "end\n",
    "\n",
    "print_my_details()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57066a26-83ae-4111-9502-36fb87b12031",
   "metadata": {},
   "source": [
    "##### las funciones se pueden combinar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "1e34d799-a07d-419d-8bf0-e1250d886b52",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "80"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function times_2(x)\n",
    "    return 2x\n",
    "end\n",
    "\n",
    "times_2(times_2(times_2(10)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93e66a80-0b29-4f11-9ee6-6e848cea0ed0",
   "metadata": {},
   "source": [
    "#### se puede definir una función en una línea sin el comando `function`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "f59c48dc-926f-496c-a1f2-5cbd22abcbf3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "80"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "times_2(x) = 2x #this defines the function \n",
    "\n",
    "times_2(times_2(times_2(10))) #this uses the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "9f72ab05-2314-4057-8242-923aeea8021a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n"
     ]
    }
   ],
   "source": [
    "#let's \"wrap\" the code we had before in a function\n",
    "function collatz(n_start)\n",
    "    n = n_start\n",
    "    while n != 1\n",
    "        print(n, \", \")\n",
    "        if n % 2 == 0 \n",
    "            n = n ÷ 2 \n",
    "        else\n",
    "            n = 3n + 1\n",
    "        end\n",
    "    end\n",
    "    println(n)\n",
    "    return nothing\n",
    "end\n",
    "\n",
    "collatz(7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "6b329be4-cd77-48dd-8309-a8e5d85a3caa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Conjetura de Collatz: \n",
      "1\n",
      "2, 1\n",
      "3, 10, 5, 16, 8, 4, 2, 1\n",
      "4, 2, 1\n",
      "5, 16, 8, 4, 2, 1\n",
      "6, 3, 10, 5, 16, 8, 4, 2, 1\n",
      "7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n",
      "8, 4, 2, 1\n",
      "9, 28, 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1\n",
      "10, 5, 16, 8, 4, 2, 1\n"
     ]
    }
   ],
   "source": [
    "println(\"Conjetura de Collatz: \")\n",
    "for n in 1:10\n",
    "    collatz(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71c02191-9907-4427-b292-1d8fe3a40b74",
   "metadata": {},
   "source": [
    "#### Multiple Dispatch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "44804daa-a516-432a-a287-52d5aa659d3f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "m_dispatch (generic function with 1 method)"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function m_dispatch(x)\n",
    "    println(x)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "e50821bc-4c6b-490d-ba02-12a9a86b7aaf",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "hello\n",
      "1.4142135623730951\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(nothing, nothing, nothing)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m_dispatch(10), m_dispatch(\"hello\"), m_dispatch(√2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "a054d60a-1bf8-46ed-83fd-c89aa564758b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "m_dispatch (generic function with 1 method)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function m_dispatch(x::Int)\n",
    "    println(x)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "df2e9609-05cc-4540-83a7-57a5dec35036",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching m_dispatch(::String)\nThe function `m_dispatch` exists, but no method is defined for this combination of argument types.\n\n\u001b[0mClosest candidates are:\n\u001b[0m  m_dispatch(\u001b[91m::Int64\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[1]:1\u001b[24m\u001b[39m\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching m_dispatch(::String)\nThe function `m_dispatch` exists, but no method is defined for this combination of argument types.\n\n\u001b[0mClosest candidates are:\n\u001b[0m  m_dispatch(\u001b[91m::Int64\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[1]:1\u001b[24m\u001b[39m\n",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[2]:1"
     ]
    }
   ],
   "source": [
    "m_dispatch(10), m_dispatch(\"hello\"), m_dispatch(√2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6001eba7-bc09-43ba-9070-cd379eef44bc",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "m_dispatch (generic function with 2 methods)"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function m_dispatch(x::String)\n",
    "    println(x)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "1b242243-957c-4061-8411-638749af6b88",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "m_dispatch (generic function with 3 methods)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function m_dispatch(x::Float64)\n",
    "    println(x)\n",
    "end"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "473ddb33-c42a-4001-be43-2d7c905cde9c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "# 3 methods for generic function <b>m_dispatch</b> from \u001b[35mMain\u001b[39m:<ul><li> m_dispatch(x::<b>Float64</b>) in Main at In[4]:1</li> <li> m_dispatch(x::<b>String</b>) in Main at In[3]:1</li> <li> m_dispatch(x::<b>Int64</b>) in Main at In[1]:1</li> </ul>"
      ],
      "text/plain": [
       "# 3 methods for generic function \"m_dispatch\" from \u001b[35mMain\u001b[39m:\n",
       " [1] m_dispatch(\u001b[90mx\u001b[39m::\u001b[1mFloat64\u001b[22m)\n",
       "\u001b[90m     @\u001b[39m \u001b[90m\u001b[4mIn[4]:1\u001b[24m\u001b[39m\n",
       " [2] m_dispatch(\u001b[90mx\u001b[39m::\u001b[1mString\u001b[22m)\n",
       "\u001b[90m     @\u001b[39m \u001b[90m\u001b[4mIn[3]:1\u001b[24m\u001b[39m\n",
       " [3] m_dispatch(\u001b[90mx\u001b[39m::\u001b[1mInt64\u001b[22m)\n",
       "\u001b[90m     @\u001b[39m \u001b[90m\u001b[4mIn[1]:1\u001b[24m\u001b[39m"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "methods(m_dispatch)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "88d365ef-db2f-4b4d-910c-276f1dce13fc",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching m_dispatch(::Complex{Int64})\nThe function `m_dispatch` exists, but no method is defined for this combination of argument types.\n\n\u001b[0mClosest candidates are:\n\u001b[0m  m_dispatch(\u001b[91m::Float64\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[4]:1\u001b[24m\u001b[39m\n\u001b[0m  m_dispatch(\u001b[91m::String\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[3]:1\u001b[24m\u001b[39m\n\u001b[0m  m_dispatch(\u001b[91m::Int64\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[1]:1\u001b[24m\u001b[39m\n",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching m_dispatch(::Complex{Int64})\nThe function `m_dispatch` exists, but no method is defined for this combination of argument types.\n\n\u001b[0mClosest candidates are:\n\u001b[0m  m_dispatch(\u001b[91m::Float64\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[4]:1\u001b[24m\u001b[39m\n\u001b[0m  m_dispatch(\u001b[91m::String\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[3]:1\u001b[24m\u001b[39m\n\u001b[0m  m_dispatch(\u001b[91m::Int64\u001b[39m)\n\u001b[0m\u001b[90m   @\u001b[39m \u001b[35mMain\u001b[39m \u001b[90m\u001b[4mIn[1]:1\u001b[24m\u001b[39m\n",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[6]:1"
     ]
    }
   ],
   "source": [
    "m_dispatch(22 + 3im)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f559fd6c-160d-4ec9-9614-0b7dd7861dc8",
   "metadata": {},
   "source": [
    "## Arrays = Data\n",
    "\n",
    "##### So up to this point we have the basics of programming including variables, logical statements, conditional statements, loops, and functions. One other major component is data. For this let us consider arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "7e9f24ab-bd92-4dc9-9505-0e244eaa58ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4-element Vector{Int64}:\n",
       "  2\n",
       "  4\n",
       " -3\n",
       " 15"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[2, 4, -3, 15] #this is an array"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce9dbacb-e9a9-4ab4-a4ff-4ba0c6b1b8b5",
   "metadata": {},
   "source": [
    "##### es un bloque de memoria RAM, una porción o segmento de memoria asignado o reservado en el sistema para almacenar datos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "0d915911-da71-46b3-b9a7-6f719b4363c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pointer(a) = Ptr{Int64} @0x000000010cf21260\n",
      "pointer(b) = Ptr{Int64} @0x000000010cf21260\n"
     ]
    }
   ],
   "source": [
    "a = [2, 4, -3, 15]\n",
    "b = a #This just makes b point to the same chunk of memory as a.\n",
    "@show pointer(a)\n",
    "@show pointer(b);"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ad98150a-48f9-4608-b86c-807a39d6487d",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "811c424e-f791-4152-b7fb-e3ec3c570fbd",
   "metadata": {},
   "source": [
    "##### se puede cer que tanto a como b \"apuntan\" a la misma dirección de memoria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9a6f803c-815a-4500-aa40-0e4e779a0114",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a[1] = 2\n",
      "a[2] = 4\n",
      "a[3] = -3\n",
      "a[4] = 15\n"
     ]
    }
   ],
   "source": [
    "@show a[1]\n",
    "@show a[2]\n",
    "@show a[3]\n",
    "@show a[4];"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7aa24753-534d-4c75-be47-2a0b32f4457a",
   "metadata": {},
   "source": [
    "##### los elementos de a son mutables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "d6c7b0ae-701a-4fd1-a185-863936610b93",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a = [2, 4, -100, 15]\n"
     ]
    }
   ],
   "source": [
    "a[3] = -100.\n",
    "@show a;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "0a6ff118-3db5-4646-8ae6-84e3dacbfd63",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "b = [2, 4, -100, 15]\n"
     ]
    }
   ],
   "source": [
    "@show b;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "e1918e52-0135-4d4c-8799-fde46d3fc4fe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfff9a01-90fa-4c72-8c39-bb9c83d028f9",
   "metadata": {},
   "source": [
    "##### los Strings son en realidad arrays de caracteres, pero INMUTABLES"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "dbaacb8d-1703-4866-ab98-63dbd1abcee1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length(mi_string) = 4\n",
      "mi_string[1] = 'H'\n",
      "mi_string[4] = 'a'\n"
     ]
    }
   ],
   "source": [
    "mi_string = \"Hola\"\n",
    "@show length(mi_string)\n",
    "@show mi_string[1]\n",
    "@show mi_string[4];"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1bc0f6e8-e70f-48f4-a08e-e45e8fa397a9",
   "metadata": {},
   "outputs": [
    {
     "ename": "LoadError",
     "evalue": "MethodError: no method matching setindex!(::String, ::Char, ::Int64)\nThe function `setindex!` exists, but no method is defined for this combination of argument types.",
     "output_type": "error",
     "traceback": [
      "MethodError: no method matching setindex!(::String, ::Char, ::Int64)\nThe function `setindex!` exists, but no method is defined for this combination of argument types.",
      "",
      "Stacktrace:",
      " [1] top-level scope",
      "   @ In[17]:1"
     ]
    }
   ],
   "source": [
    "mi_string[4] = 'x'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dadddd1b-12b0-487c-aa3a-bce00a557349",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "930ebdf5-2903-40d1-ad38-aec4079cb8c3",
   "metadata": {},
   "source": [
    "##### los arrays no tienen que tener un mismo tipo en cada elementp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "42b35060-5883-4074-b2f6-a5ac38bfd069",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6-element Vector{Any}:\n",
       "  \"Hola\"\n",
       " 2\n",
       "  sqrt (generic function with 19 methods)\n",
       " 3.4\n",
       "  'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)\n",
       "  [1, 2, 3]"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mi_otro_array = [\"Hola\", 2, sqrt, 3.4, 'c', [1, 2, 3]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e4eb26d8-3191-4e22-86dc-c4291be3abaa",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e3a15e8f-4794-440e-a477-2660372e1395",
   "metadata": {},
   "source": [
    "##### una función que suma los elementos (supuestos nume2ricos de un array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "85e9d3a1-8369-4e68-9f06-70060ba7a54b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1111"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function my_sum(input_array)\n",
    "    total = 0\n",
    "    for i in 1:length(input_array)\n",
    "        total += input_array[i]\n",
    "    end\n",
    "    return total\n",
    "end\n",
    "\n",
    "a = [1, 10, 100, 1000]\n",
    "my_sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "66d010af-7682-4e69-a4f5-0ee8317a7e6b",
   "metadata": {},
   "source": [
    "##### existe una **función predefinida o integrada (in-built function)** que hace esto mismo (en menos tiempo SIEMPRE)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "2ecad60d-345d-4aad-9b78-cd1b50f5257a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1111"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36d8b479-fbad-496c-a7e5-5d0c65000440",
   "metadata": {},
   "source": [
    "##### la función sum, permite hacer más cosas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "9a1c519e-dc87-44f4-ad14-adb3a8c3784e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum(a) = 909\n",
      "sum(abs, a) = 1111\n"
     ]
    }
   ],
   "source": [
    "a = [-1,10,-100,1000]\n",
    "@show sum(a)\n",
    "@show sum(abs, a); #sum the absolute values"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2bd57fe-6d08-4225-a5a6-e54324384903",
   "metadata": {},
   "source": [
    "##### Arrays can be extended with the push! function. Note that the ! is part of the function name and indicates to us that the function modifies the array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "4f17e10c-cc70-42ad-9a52-80cccf6f04a4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my_array = [-3]\n",
      "my_array = [-3, 10]\n"
     ]
    }
   ],
   "source": [
    "my_array = Int[] #empty array of integers\n",
    "push!(my_array, -3)\n",
    "@show my_array\n",
    "push!(my_array, 10)\n",
    "@show my_array;"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5a9724d-8744-455b-87a4-c28efb001c23",
   "metadata": {},
   "source": [
    "##### modifiquemoslas la función collatz para que devuelva la sucesión dentro de un array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "6d9ba24f-7922-4e35-8fcb-a1825017fc6d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17-element Vector{Int64}:\n",
       "  7\n",
       " 22\n",
       " 11\n",
       " 34\n",
       " 17\n",
       " 52\n",
       " 26\n",
       " 13\n",
       " 40\n",
       " 20\n",
       " 10\n",
       "  5\n",
       " 16\n",
       "  8\n",
       "  4\n",
       "  2\n",
       "  1"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "function collatz(n_start)\n",
    "    sequence = Int[]\n",
    "    n = n_start\n",
    "    while n != 1\n",
    "        push!(sequence, n) # was before print(n, \", \")\n",
    "        if n % 2 == 0 \n",
    "            n = n ÷ 2 \n",
    "        else\n",
    "            n = 3n + 1\n",
    "        end\n",
    "    end\n",
    "    push!(sequence, n) # was before println(n)\n",
    "    return sequence # was before return nothing\n",
    "end\n",
    "\n",
    "collatz(7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6828222d-3699-48f3-8ba0-b7f7a0461603",
   "metadata": {},
   "source": [
    "##### La [Conjetura de Collatz](https://en.wikipedia.org/wiki/Collatz_conjecture) dice que para cualquier valor de entrada la sucesión termina en 1, será?:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "ae9c51d8-2843-41da-8145-43044dc56527",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.332836 seconds (4.45 M allocations: 3.092 GiB, 16.77% gc time)\n"
     ]
    }
   ],
   "source": [
    "@time for n in 1:10^6\n",
    "    collatz(n)\n",
    "end"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a44854d8-9526-44be-ab10-d05b9e4cbccb",
   "metadata": {},
   "source": [
    "##### en el primer millón de números funcionó"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73911106-1605-433c-92db-0c7de0134711",
   "metadata": {},
   "source": [
    "##### Cuál fue la serie más larga en esas primeras 10^6 corridas?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "0c200b63-4177-4dc7-9958-9ead5ab878ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  0.000000 seconds\n",
      "Longest sequence is of length 525 when you start at 837799.\n"
     ]
    }
   ],
   "source": [
    "length_of_longest = 0\n",
    "n_of_longest = 1\n",
    "for n in 1:10^6\n",
    "    seq_len = length(collatz(n))\n",
    "    if seq_len > length_of_longest\n",
    "        length_of_longest = seq_len\n",
    "        n_of_longest = n\n",
    "    end\n",
    "end\n",
    "\n",
    "println(\"Longest sequence is of length $length_of_longest when you start at $n_of_longest.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "0389f317-cc1a-4a47-a9e1-5a0ef08c516d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(525, 837799)"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "maximum([length(collatz(n)) for n in 1:10^6]) #con función integrada\n",
    "findmax([length(collatz(n)) for n in 1:10^6])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "074488bc-6c86-4a91-8067-7fd91007d617",
   "metadata": {},
   "source": [
    "#### otra forma de crear un array es usando **(array comprehension) comprensión de arreglos, matrices o listas**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "eeb46838-1abe-46f5-86b8-5f556dadab7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10-element Vector{Int64}:\n",
       "   1\n",
       "   4\n",
       "   9\n",
       "  16\n",
       "  25\n",
       "  36\n",
       "  49\n",
       "  64\n",
       "  81\n",
       " 100"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i^2 for i in 1:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "aa7aca7a-2ace-40f2-b66e-9ad2525c2f55",
   "metadata": {},
   "source": [
    "## **Microproyectos en el Aula**\n",
    "\n",
    "Aquí hay varios microproyectos diseñados para proporcionar práctica utilizando los conceptos mencionados anteriormente. Para cada uno de ellos, es posible que necesites un poco más de funcionalidad y funciones integradas de las que hemos explorado hasta ahora. Puedes obtener esa información mediante búsqueda web, ayuda de un modelo de lenguaje (LLM), ayuda de compañeros o ayuda del personal.\n",
    "\n",
    "**Microproyecto 1**: Escribe un pequeño programa que le haga a un estudiante un cuestionario de aritmética con las operaciones de suma (+), resta (-), multiplicación (*) y división. Los números de entrada están en el rango de 1 a 200. Se les hacen preguntas a los estudiantes y deben responder con la respuesta correcta. Después de 10 preguntas, el estudiante recibe un resumen de cuántas respuestas correctas tuvo y cuáles fueron incorrectas. Es posible que necesites explorar las funciones de lectura de línea (readline) y análisis (parse).\n",
    "\n",
    "**Microproyecto 2**: Escribe un pequeño programa que sea un juego de Tic-Tac-Toe (tres en raya) entre dos jugadores. En cada turno, se imprime nuevamente el estado del tablero. Puedes usar los números del 1 al 9 como entradas para las celdas.\n",
    "\n",
    "**Microproyecto 3**: Escribe un programa que trabaje con una cadena larga de texto fija (por ejemplo, varios párrafos de texto como el que describe estos microproyectos). El programa debe mostrar el conteo de caracteres, el conteo de palabras, y tal vez otras estadísticas sobre el texto."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98fc03da-04b5-4f5e-946f-de41ab835095",
   "metadata": {},
   "source": [
    "# Practice questions for the practice quiz\n",
    "\n",
    "1. Consider the `Julia` code:\n",
    "```Julia\n",
    "a = [\"$i\" for i in 1:3]\n",
    "s = a[1]*a[2]*a[3]\n",
    "```\n",
    "What is the `type` and value of `s`?\n",
    "\n",
    "2. You want to write a function `my_minimum` that gets an array of numbers and returns the minimal value in the array. Do not use the minimum in-built function as part of your answer.\n",
    "```Julia\n",
    "function my_minimum(a)\n",
    "\n",
    "    return minimal_value\n",
    "end\n",
    "```\n",
    "Fill in the `code` for the `function`.\n",
    "\n",
    "3. You want to write a `Julia` function `num_sub_str` which accepts a string `main_string` and a string `sub_string`, and returns a count of how many times `sub_string` is in `main_string`.\n",
    "```Julia\n",
    "function num_sub_str(main_string, sub_string)\n",
    "\n",
    "    return number_occurances\n",
    "end\n",
    "```\n",
    "Fill in the code for the function.\n",
    "\n",
    "4. Consider the `Julia` function, `tamid_nahon` which gets two boolean values as inputs, `a`, and `b`.\n",
    "```Julia\n",
    "function tamid_nahon(a, b)\n",
    "    return !(a && b) == !a || !b\n",
    "end\n",
    "```\n",
    "For what combinations of `a` and `b` is the return value `true`? For what is it `false`?\n",
    "\n",
    "5. The Fibbonaci sequence is 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, ... (every element is the sum of the previous two and the initilization is 0, 1). Write a `Julia` function that computes the first n terms of the Fibbonaci sequence, returning these terms in an array.\n",
    "```Julia\n",
    "function fibbonaci(n)\n",
    "    arr = [0, 1]\n",
    "\n",
    "\n",
    "    return arr\n",
    "end\n",
    "```\n",
    "Fill in the code for the function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05b67776-f277-44ee-98e9-41c6bd12ef8c",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.11.1 1.11.1",
   "language": "julia",
   "name": "julia-1.11.1-1.11"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}