{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Introducción a la Programación en MATLAB (C3)\n", "\n", "Mauricio Tejada\n", "\n", "ILADES - Universidad Alberto Hurtado\n", "\n", "Agosto 2017\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Contenidos\n", "\n", "- [Matrices](#3.-Matrices)\n", " - [Secuencias](#3.1-Secuencias)\n", " - [Matrices Especiales](#3.2-Matrices-Especiales)\n", " - [Operaciones con Matrices](#3.3-Operaciones-con-Matrices)\n", " - [Referenciación y Submatrices](#3.4-Referenciación-y-Submatrices)\n", " - [Concatenar Matrices](#3.4-Referenciación-y-Submatrices)\n", " - [Matrices de Mayor Dimensión](#3.6-Matrices-de-Mayor-Dimensión)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Matrices\n", "\n", "Matlab es un lenguaje de programación basado en matrices. \n", "\n", "- Una matriz es un arreglo bidireccional que contiene números reales o complejos. Una matriz de dimensión $n \\times m$ tiene $n$ filas y $m$ columnas. \n", "\n", "- Escalares en Matlab están representados por matrices $1 \\times 1$. \n", "- Vectores fila (columna) están representados por matrices $n \\times 1$ ($1 \\times n$), con $n$ el tamaño.\n", "\n", "Existen dos formas de definir matrices: usando el teclado y/o leyendo archivos externos (de texto, excel, etc). \n", "\n", "- *Usando el teclado:* Toda matriz se inicia y termina con `[ ]`, las columnas están separadas por espacios (o comas) y las columnas por punto y coma. \n", "- *Leyendo archivos externos:* Se usan los comandos `textread`, `cvsread`, `xlsread`, etc. Más adelante veremos detalles." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A =\n", "\n", " 1 2 3\n", " 4 5 6\n", " 7 8 9\n" ] } ], "source": [ "A = [1 2 3; 4 5 6; 7 8 9]" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "B =\n", "\n", " 1 2 3\n", " 4 5 6\n", "\n", "\n", "C =\n", "\n", " 1\n", " 2\n", " 3\n", "\n", "\n", "D =\n", "\n", " 1 4 3\n" ] } ], "source": [ "B = [1 2 3; 4 5 6]\n", "C = [1; 2; 3]\n", "D = [1 4 3]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.1 Secuencias\n", "\n", "Es posible crear vectores a partir de secuencias con valores equidistantes unos de otros.\n", "\n", "- Forma 1: `inicio:incremento:fin` (incremento por defecto = 1). La secuencia termina en el número más cercano al número final definido.\n", "- Forma 2: `linspace(inicio,fin,numero)` (el incremento es calculado automáticamente).\n", "\n", "Adicionalmente, existe la posibilidad de crear secuencias con número espaciados logarítmicamente.\n", "\n", "- Forma 3: `logspace(inicio,fin,numero)` crea un vector de `numero` elementos en el intervalo [10^inicio,10^fin] espaciados logarítmicamente." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H0 =\n", "\n", " 1 2 3 4 5 6 7 8 9 10\n" ] } ], "source": [ "H0 = (1:10)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H1 =\n", "\n", " 1.0000 1.6000 2.2000 2.8000\n" ] } ], "source": [ "H1 = 1:0.6:3" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H2 =\n", "\n", " 1.0000 0.8200 0.6400 0.4600 0.2800 0.1000\n" ] } ], "source": [ "H2 = linspace(1,0.1,6)" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "H3 =\n", "\n", " 10 100 1000\n" ] } ], "source": [ "H3 = logspace(1,3,3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.2 Matrices Especiales\n", "\n", "Matlab tiene funciones especialmente diseñadas para construir cierto tipo de matrices:\n", "\n", "- Matrices de ceros: `zeros(nfilas,ncolumnas)`\n", "- Matrices de unos: `ones(nfilas,ncolumnas)`\n", "- Matriz identidad: `eye(dimesion)`\n", "- Matrices con números aleatorios: `rand(nfilas,ncolumnas)` (uniforme [0,1]) y `randn(nfilas,ncolumnas)` (Normal estándar)." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ME1 =\n", "\n", " 0 0\n", " 0 0\n", " 0 0\n" ] } ], "source": [ "ME1 = zeros(3,2)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ME2 =\n", "\n", " 1\n", " 1\n", " 1\n", " 1\n" ] } ], "source": [ "ME2 = ones(4,1)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ME3 =\n", "\n", " 1 0 0\n", " 0 1 0\n", " 0 0 1\n" ] } ], "source": [ "ME3 = eye(3)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ME4 =\n", "\n", " 0.8147 0.1270\n", " 0.9058 0.9134\n" ] } ], "source": [ "ME4 = rand(2,2)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ME5 =\n", "\n", " 0.3188\n", " -1.3077\n", " -0.4336\n" ] } ], "source": [ "ME5 = randn(3,1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notas: \n", "- Para generar número aleatorios de una distribución Normal con media $\\mu$ y desviación estándar $\\sigma$ usamos `mu+sig*randn(nfilas,ncols)`. \n", "- Para generar número aleatorios de una distribución Uniforme definida en el intervalo $[a,b]$ usamos `a+(b-a)rand(nfilas,ncols)`." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "xn =\n", "\n", " 2.1713 1.3251 1.9685\n", " 3.7892 3.5175 2.3574\n", " 3.3847 2.3627 1.8975\n", "\n", "\n", "xu =\n", "\n", " 2.8435 3.5844\n", " 3.8315 3.9190\n" ] } ], "source": [ "xn = 2+0.5*randn(3,3)\n", "xu = 2+(4-2)*rand(2,2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.3 Operaciones con Matrices\n", "\n", "El álgebra lineal define operaciones matriciales que Matlab es capaz de realizar. Todas las operaciones matriciales deben cumplir con los requerimiento de conformabilidad apropiados a la operación, caso contrario Matlab indicara que existe un error. \n", "\n", "- Suma `+` \n", "- Sustracción `-` " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A =\n", "\n", " 1 2 3\n", " 4 5 6\n", " 7 8 9\n", "\n", "\n", "B =\n", "\n", " 1 1 1\n", " 2 2 2\n", " 3 3 3\n", "\n", "\n", "S =\n", "\n", " 2 3 4\n", " 6 7 8\n", " 10 11 12\n", "\n", "\n", "R =\n", "\n", " 0 1 2\n", " 2 3 4\n", " 4 5 6\n" ] } ], "source": [ "A = [1 2 3; 4 5 6; 7 8 9]\n", "B = [1 1 1; 2 2 2; 3 3 3]\n", "\n", "S = A + B\n", "R = A - B" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Multiplicación `*`\n", "- Potencia `^`" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "MM =\n", "\n", " 14 14 14\n", " 32 32 32\n", " 50 50 50\n", "\n", "\n", "P =\n", "\n", " 30 36 42\n", " 66 81 96\n", " 102 126 150\n" ] } ], "source": [ "MM = A*B\n", "P = A^2 % Idem P = A*A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Traspuesta `'`\n", "- Inversa `inv(matriz)`\n", "- División Izquierda '\\' ($A^{-1}\\times B$)\n", "- División Derecha '/' ($B \\times A^{-1}$)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "C =\n", "\n", " 0.6557 0.9340 0.7431\n", " 0.0357 0.6787 0.3922\n", " 0.8491 0.7577 0.6555\n", "\n", "\n", "Ctrans =\n", "\n", " 0.6557 0.0357 0.8491\n", " 0.9340 0.6787 0.7577\n", " 0.7431 0.3922 0.6555\n", "\n", "\n", "IV =\n", "\n", " -6.6730 2.2190 6.2376\n", " -13.9906 9.0904 10.4219\n", " 24.8178 -13.3832 -18.6027\n", "\n", "\n", "DI =\n", "\n", " 45.8661 47.6497 49.4332\n", " 95.3245 100.8463 106.3681\n", " -158.9337 -166.1017 -173.2698\n" ] } ], "source": [ "C = rand(3,3)\n", "Ctrans = C'\n", "IV = inv(C)\n", "DI = C \\ A % Idem DI = inv(C)*A" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Operaciones elemento por elemento usan un punto precediendo al operador: `.*`, `.^`, `./`." ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A =\n", "\n", " 1 2 3\n", " 4 5 6\n", " 7 8 9\n", "\n", "\n", "B =\n", "\n", " 1 1 1\n", " 2 2 2\n", " 3 3 3\n", "\n", "\n", "Me =\n", "\n", " 1 2 3\n", " 8 10 12\n", " 21 24 27\n", "\n", "\n", "Pe =\n", "\n", " 1 4 9\n", " 16 25 36\n", " 49 64 81\n" ] } ], "source": [ "A\n", "B\n", "Me = A.*B\n", "Pe = A.^2" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "v =\n", "\n", " 1\n", " 2\n", " 3\n", "\n", "\n", "g =\n", "\n", " 3\n", " 4\n", " 5\n", "\n", "\n", "ans =\n", "\n", " 3\n", " 8\n", " 15\n" ] } ], "source": [ "v = [1 2 3]'\n", "g = [3 4 5]'\n", "\n", "v.*g" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.4 Referenciación y Submatrices\n", "\n", "Los elementos se una matriz se pueden referenciar de diversas formas:\n", "\n", "- Usando `matriz(i,j)` donde `i` es la fila y `j` es la columna." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A =\n", "\n", " 1 2 3\n", " 4 5 6\n", " 7 8 9\n" ] } ], "source": [ "A" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a22 =\n", "\n", " 5\n", "\n", "\n", "a31 =\n", "\n", " 7\n" ] } ], "source": [ "a22 = A(2,2)\n", "a31 = A(3,1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Usando `matriz(ii:if,ji:jf)` para extraer más de un elemento. `ii` e `if` corresponden a la fila inicial y la fila final (lo mismo aplica a `ci` y `cf` para las columnas). Este método se usa para extraer submatrices o particionar." ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ans =\n", "\n", " 1 2\n", " 4 5\n" ] } ], "source": [ "A([1 2],[1 2])" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "subA1 =\n", "\n", " 1 2\n", " 4 5\n", "\n", "\n", "subA2 =\n", "\n", " 4 5 6\n", " 7 8 9\n" ] } ], "source": [ "subA1 = A(1:2,1:2)\n", "subA2 = A(2:3,1:3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Usar únicamente `:` indica toda la fila o columna según corresponda. El término `end` indica el último elemento." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "subA3 =\n", "\n", " 4 5 6\n", "\n", "\n", "subA4 =\n", "\n", " 2 3\n", " 5 6\n", " 8 9\n", "\n", "\n", "subA5 =\n", "\n", " 6\n", " 9\n" ] } ], "source": [ "subA3 = A(2,:)\n", "subA4 = A(:,2:3)\n", "subA5 = A(2:end,3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Note que al usar matriz(ii:if,ji:jf) no estamos haciendo otra cosa que definir un vector secuencia dentro la matriz. Por tanto es válido usar vectores para referenciar elementos (en secuencia o no). " ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "B =\n", "\n", " 0.1712 0.0462 0.3171 0.3816 0.4898 0.7547\n", " 0.7060 0.0971 0.9502 0.7655 0.4456 0.2760\n", " 0.0318 0.8235 0.0344 0.7952 0.6463 0.6797\n", " 0.2769 0.6948 0.4387 0.1869 0.7094 0.6551\n", "\n", "\n", "Ind =\n", "\n", " 1 2 3 4\n", "\n", "\n", "subB1 =\n", "\n", " 0.4898\n", " 0.4456\n", " 0.6463\n", " 0.7094\n", "\n", "\n", "subB2 =\n", "\n", " 0.4898\n", " 0.4456\n", " 0.6463\n", " 0.7094\n" ] } ], "source": [ "B=rand(4,6)\n", "Ind = 1:4\n", "subB1 = B(Ind,5)\n", "subB2 = B(1:4,5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Podemos usar la misma lógica para elegir elementos que no son contiguos:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Indc =\n", "\n", " 1 3 4\n", "\n", "\n", "Indf =\n", "\n", " 2 4\n", "\n", "\n", "subB3 =\n", "\n", " 0.7060 0.9502 0.7655\n", " 0.2769 0.4387 0.1869\n" ] } ], "source": [ "Indc = [1 3 4]\n", "Indf = [2 4]\n", "subB3 = B(Indf,Indc)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.5 Concatenar Matrices\n", "\n", "Para concatenar matrices usamos los mismos procedimientos que para la definición de matrices usando el teclado, la única diferencia está en que los elementos son matrices. \n", "\n", "- La matriz se define en `[]`.\n", "- Concatenar horizontalmente `,` o ` ` (espacio).\n", "- Concatenar verticalmente `;`.\n", "\n", "Nota: Ser cuidadoso con la conformabilidad de las matrices." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A =\n", "\n", " 0.1626 0.9597\n", " 0.1190 0.3404\n", " 0.4984 0.5853\n", "\n", "\n", "B =\n", "\n", " 0.2238 0.2551\n", " 0.7513 0.5060\n", "\n", "\n", "C =\n", "\n", " 0.1626 0.9597\n", " 0.1190 0.3404\n", " 0.4984 0.5853\n", " 0.2238 0.2551\n", " 0.7513 0.5060\n", "\n", "\n", "D =\n", "\n", " 0.1626 0.1190 0.4984 0.2238 0.2551\n", " 0.9597 0.3404 0.5853 0.7513 0.5060\n" ] } ], "source": [ "A = rand(3,2)\n", "B = rand(2,2)\n", "\n", "C = [A ; B] % Concatenar verticalmente A y B\n", "D = [A' B] % Concatenar horizontalmente la traspuesta de A con B" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 3.6 Matrices de Mayor Dimensión\n", "\n", "Matlab es capaz de manipular matrices de mayor dimensión (ejemplo 3D). Todas las reglas de creación, referenciación, partición y concatenación aplican.\n", "\n", "*Nota: Sólo operaciones elemento por elemento son utilizables con matrices de mayor dimensión.*" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "A(:,:,1) =\n", "\n", " 0.6991 0.5472 0.2575\n", " 0.8909 0.1386 0.8407\n", " 0.9593 0.1493 0.2543\n", "\n", "\n", "A(:,:,2) =\n", "\n", " 0.8143 0.3500 0.6160\n", " 0.2435 0.1966 0.4733\n", " 0.9293 0.2511 0.3517\n", "\n", "\n", "A(:,:,3) =\n", "\n", " 0.8308 0.9172 0.7537\n", " 0.5853 0.2858 0.3804\n", " 0.5497 0.7572 0.5678\n" ] } ], "source": [ "A = rand(3,3,3)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Asub =\n", "\n", " 0.2858\n" ] } ], "source": [ "Asub = A(2,2,3)" ] } ], "metadata": { "kernelspec": { "display_name": "Matlab", "language": "matlab", "name": "matlab" }, "language_info": { "file_extension": ".m", "help_links": [ { "text": "MetaKernel Magics", "url": "https://github.com/calysto/metakernel/blob/master/metakernel/magics/README.md" } ], "mimetype": "text/x-octave", "name": "matlab", "version": "0.9.4" } }, "nbformat": 4, "nbformat_minor": 1 }