I-1-Julia.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Álgebra Lineal en Julia Language\n",
    "## Introducción\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En este anexo se da una introducción práctica al uso de Julia en el ámbito del Álgebra Lineal.\n",
    "\n",
    "Recomendamos la lectura y revisión previa de los siguientes documentos:\n",
    "   * [https://julialang.org/learning/](https://julialang.org/learning/)\n",
    "   * [Learn Julia in a few minutes](https://learnxinyminutes.com/docs/julia/)\n",
    "   * [S. Boyd, L. Vandenberghe. Introduction to Applied Linear Algebra](https://drive.google.com/file/d/1qpU_9I3HuVngVE0b4clqhFFfwd_LCHGE/view)\n",
    "   * [S. Boyd, L. Vandenberghe. Introduction to Applied Linear Algebra Julia Companion](https://drive.google.com/file/d/1leiND2qpAon5ZqBPXeJHe0g1BBJPU5Ne/view)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cargamos el Paquete:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "using LinearAlgebra"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Vectores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Vectores Renglón.** \n",
    ">\n",
    "> En ``` Julia 1.0.3 ``` los **vectores renglón** los escribimos como: ``` x=[1 2 3] ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=[1 2 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Julia` nos indica que el vector es de tipo `1×3 Array{Int64,2}`, es decir un arreglo de enteros de tamaño `1×3`, el `2` indica que es un arreglo de dos índices. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Vectores Columna.**\n",
    ">\n",
    ">Los **vectores columna** los definimos por medio de la ***función transposición***, que en `Julia` se indica por medio del símbolo: `'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y=x'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`y=x'` Indica que `y` es el *vector columna* que resulta de transponer el *vector renglón* `x`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Julia` nos indica que el vector es de tipo `3×1 LinearAlgebra.Adjoint{Int64,Array{Int64,2}}`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "w=[1.2 .2 3.16]'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operaciones entre vectores en ``` Julia ```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las operaciones básicas son la suma de dos vectores y la multiplicación de un vector por un escalar:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Suma.** \n",
    ">\n",
    "> Para sumar dos *vectores* usamos el operador suma: `+` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "y+w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Multiplicación por escalar.**\n",
    ">\n",
    ">Para multiplicar un *vector* por un *escalar* usamos el operador multiplicación: `*` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "2*[2 3 1 5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "3*[3 9 1 0 -1]'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos indicar diferentes operaciones simultáneas, por ejemplo para obtener el vector: $$\\begin{pmatrix} 2\\\\ 4\\\\ 0\\\\ 1\\end{pmatrix} -3\\begin{pmatrix} 3\\\\ 8\\\\ 1\\\\ 2\\end{pmatrix}+5\\begin{pmatrix} \\ \\ \\ 0\\\\ -2\\\\ \\ \\ \\  3\\\\ -5\\end{pmatrix}  $$ escribimos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[2 4 0 1]'-3*[3 8 1 2]'+5*[0 -2 3 -5]'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Ejercicio** Dados los vectores $$x=\\begin{pmatrix}\\ \\ \\ 8.2 \\\\ - 4.7 \\\\ \\ \\ \\ 5.6\\\\ - 1.2 \\\\ \\ \\   \\ 7.5 \\end{pmatrix}, y=\\begin{pmatrix} - 6.7 \\\\ \\ \\ \\ 2.3 \\\\  -2.6 \\\\ - 4.5 \\\\ \\ \\ \\ 7.7 \\end{pmatrix}, z=\\begin{pmatrix}\\ \\ \\ 8.3 \\\\\\ \\ \\ 4.8 \\\\ \\  \\ \\ 9.1 \\\\\\  \\ \\ 5.5 \\\\ - 2.2 \\end{pmatrix} $$\n",
    "Determinar el vector $w$ dado por:\n",
    " 1. $w=3x-y+4z$\n",
    " 2. $w=x+2y-6z$\n",
    " 3. $w=5x+2y+8z$\n",
    " 4. $w=-4x-7y+4z$\n",
    " 5. $w=-x+3y-2z$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Producto Punto"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **LinearAlgebra.dot — Function.** En `dot(x, y)` o `⋅(x,y)` Calcula el producto punto entre dos vectores."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Ejemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u=[1.0 2.3 7.4]';\n",
    "v=[3.5 6.2 4.0]';"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot(u,v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "El símbolo `;` después de una instrucción suprime la visualización de salida de una línea de código."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot([1.0 2.0],[-2.0 1.0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[1 2 3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot(a,a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Norma de un vector\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **LinearAlgebra.norm — Function.** En `norm(A, p::Real=2)` Para cualquier contenedor iterable `A` (incluidas las matrices de cualquier dimensión) de números (o cualquier tipo de elemento para el que se define la norma), **norm** calcula la norma `p` (por defecto `p = 2`) como si `A` fuera un vector.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Ejemplos:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u=[0 0 0 1 0 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "norm(u)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v=[1 1 1 1 0 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "norm(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ejercicio dados $u,v\\in \\mathbb{R}^n$ encontrar $w\\in \\mathbb{R}^n$ tal que $w$ sea ortogonal a $v$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Matrices"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Matrices.** \n",
    ">\n",
    "> En ``` Julia 1.0.3 ``` las **matrices** las podemos escribimos como, arreglos de arreglos: ``` A=[[1 2 3] ; [ 3 2 0]] ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=[[1 2 3] ; [ 3 2 0]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen diferentes sintaxis equivales"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A₂=[1 2 3 ;  3 2 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En `Julia`, puedes emplear **caracteres unicode** para notación matemática, además podemos usar **subíndices** y **super índices** para nombrar las variables."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Caracteres Unicode\n",
    "\n",
    "> `\\comando` + `TAB`\n",
    "\n",
    "Los comandos son como los de LaTeX. Por ejemplo:\n",
    "\n",
    "- `\\theta` + `TAB`  $\\quad\\longrightarrow\\quad\\theta$\n",
    "\n",
    "\n",
    "### Subíndices y super índices\n",
    "\n",
    "Para el subíndice usamos\n",
    "\n",
    "> `\\_` + `2` + `SHIFT`\n",
    "\n",
    "mientras que para el superíndice \n",
    "\n",
    "> `\\^` + `2` + `SHIFT`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos definir una matriz de variables aleatorias:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = rand(1:10,3,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "En el ejemplo anterior se llena una matriz de `3×3` con enteros del 1 al 10 elegidos de forma aleatoria con distribución normal."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existen algunas funciones especiales como en otros lenguajes: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=ones(3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C=zeros(5,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Usa `I` para realizar operaciones con la matriz identidad correspondiente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "C+I"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La multiplicación se realiza con el operador: `*`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=A*x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La suma de matrices es como en otros lenguajes "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A₁=rand(1:10,4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A₂=rand(1:10,4,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A₁+A₂"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Traspuesta\n",
    "Como en otros lenguajes, `A'` es la transpuesta conjugada."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A=rand(1:10,3,3)+im*rand(1:10,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Números complejos y racionales\n",
    "En `Julia` para expresar números complejos y los racionales se utiliza la siguiente sintaxis:\n",
    "\n",
    " * `5+3im` representa el complejo `5+3i`\n",
    " * `3//5` representa el racional $\\frac{3}{5}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Resolviendo sistemas lineales\n",
    "El problema $Ax=b$ para $A$ cuadrada se resulve con la función `\\`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = rand(1:10,3,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=rand(1:10,3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x=A\\b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "A*x"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Julia 1.0.3",
   "language": "julia",
   "name": "julia-1.0"
  },
  "language_info": {
   "file_extension": ".jl",
   "mimetype": "application/julia",
   "name": "julia",
   "version": "1.0.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}