aula-08a-matrizes-vetores.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Álgebra Linear Computacional básica"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Objetivos\n",
    "\n",
    "- Associar conceitos abstratos de Álgebra Linear a estruturas computacionais; \n",
    "- Realizar operações básicas com vetores e matrizes;\n",
    "- Saber como resolver sistemas lineares de pequeno porte;\n",
    "- Calcular autovalores e autovetores em matrizes reais;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Introdução\n",
    "\n",
    "Neste capítulo, mostraremos como realizar operações básicas entre matrizes e vetores usando o computador. A manipulação de matrizes e vetores é essencial em muitas ciências, principalmente para resolver sistemas lineares. \n",
    "\n",
    "As matrizes são utilizadas na computação para armazenar informações bidimensionais. Em particular, podem representar translação, rotação, escalonamento e sistemas de equações. O estudo da relação entre algoritmos e métodos computacionais para trabalhar eficientemente com matrizes e vetores é realizado no âmbito da _Álgebra Linear Computacional_."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matrizes e vetores\n",
    "\n",
    "Uma matriz ${\\bf A}$ de ordem $m \\times n$ pode ser escrita como:\n",
    "\n",
    "$${\\bf A} = \n",
    "\\begin{bmatrix}\n",
    "a_{11} & a_{12} & \\ldots & a_{1n} \\\\\n",
    "a_{21} & a_{22} & \\ldots & a_{2n} \\\\\n",
    "\\vdots & \\vdots & \\ddots & \\vdots \\\\\n",
    "a_{m1} & a_{m2} & \\ldots & a_{mn}\n",
    "\\end{bmatrix}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As colunas de uma matriz com $m$ linhas correspondem a $n$ vetores $\\vec{v}_1, \\vec{v}_2, \\ldots,\\vec{v}_n$, de maneira que\n",
    "\n",
    "$${\\bf A} = \n",
    "\\begin{bmatrix}\n",
    "\\vec{v}_1 & \\vec{v}_2 & \\ldots & \\vec{v}_n \\\\\n",
    "\\end{bmatrix}$$\n",
    "\n",
    "é uma representação equivalente para a matriz anterior."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, usamos o módulo _numpy_ para trabalhar com matrizes e vetores. Vetores são _arrays_ 1D, ao passo que matrizes são _arrays_ 2D, ou seja, um \"_array_ de _arrays_\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemplo.** Represente computacionalmente os vetores do $\\mathbb{R}^3$ a seguir:\n",
    "\n",
    "- $\\vec{u} = 3\\vec{i} - 2\\vec{j} + 9\\vec{k}$\n",
    "- $\\vec{v} = -2\\vec{i} + 4\\vec{j}$\n",
    "- $\\vec{w} = \\vec{i}$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{note}\n",
    "O _NumPy_ possui uma classe especial para se trabalhar com matrizes e vetores em uma ou duas dimensões, a saber o tipo `matrix`, ou `mat`. Com objetos `matrix`, as  operações particulares de multiplicação matriz-matriz ou matriz-vetor comportam-se diferentemente daquelas na classe `ndarray`. Neste texto, abordaremos apenas os tipos `ndarray` porque são aplicáveis também a matrizes multidimensionais.\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 3 -2  9]\n",
      "[-2  4  0]\n",
      "[1 0 0]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "u = np.array([3,-2,9])\n",
    "v = np.array([-2,4,0])\n",
    "w = np.array([1,0,0])\n",
    "print(u), print(v), print(w);\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemplo.** Represente computacionalmente a matriz 3 x 3 dada por\n",
    "\n",
    "$${\\bf A} = \n",
    "\\begin{bmatrix}\n",
    "\\vec{u} & \\vec{v} & \\vec{w} \\\\\n",
    "\\end{bmatrix}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que os vetores devem ser escritos como \"coluna\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3 -2  1]\n",
      " [-2  4  0]\n",
      " [ 9  0  0]]\n",
      "[[ 3 -2  9]\n",
      " [-2  4  0]\n",
      " [ 1  0  0]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[3,-2,1],[-2,4,0],[9,0,0]])\n",
    "print(A)\n",
    "\n",
    "print(A.T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemplo.** Represente computacionalmente a matriz \n",
    "\n",
    "$$ \n",
    "\\begin{bmatrix}\n",
    "2 & -2 \\\\\n",
    "4 & 1 \\\\\n",
    "2 & 1 \n",
    "\\end{bmatrix}$$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos escrever linha por linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2 -2]\n",
      " [ 4  1]\n",
      " [ 2  1]]\n"
     ]
    }
   ],
   "source": [
    "L1 = np.array([2,-2]) # linha 1\n",
    "L2 = np.array([4,1]) # linha 2\n",
    "L3 = np.array([2,1]) # linha 3\n",
    "\n",
    "A2 = np.array([L1,L2,L3]) # lista de listas\n",
    "print(A2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Diretamente, poderíamos também definir: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2 -2]\n",
      " [ 4  1]\n",
      " [ 2  1]]\n"
     ]
    }
   ],
   "source": [
    "A3 = np.array([[2,-2],[4,1],[2,1]])\n",
    "print(A3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que cada lista representa uma linha. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transposição \n",
    "\n",
    "Matrizes e vetores podem ser transpostos com `.T`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  2]\n",
      " [-2  1  1]]\n"
     ]
    }
   ],
   "source": [
    "A2T = A2.T\n",
    "print(A2T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Assim, com as variáveis antes definidas, poderíamos, equivalentemente, fazer para ${\\bf A}$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 3 -2  1]\n",
      " [-2  4  0]\n",
      " [ 9  0  0]]\n"
     ]
    }
   ],
   "source": [
    "# modo 2: matriz transposta\n",
    "At = np.array([u,v,w]).T \n",
    "print(At)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Teste de igualdade \n",
    "\n",
    "Podemos verificar a igualdade entre matrizes como"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ True,  True,  True],\n",
       "       [ True,  True,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A == At"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No caso de vetores:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ True,  True,  True])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# vetor \"linha\" não difere\n",
    "# do vetor \"coluna\"\n",
    "u == u.T "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operações fundamentais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Adição e subtração\n",
    "\n",
    "A adição (subtração) de matrizes e vetores pode ser realizada de modo usual com computação vetorizada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemplo:** $\\vec{u} \\pm \\vec{v}$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 9]\n",
      "[ 5 -6  9]\n"
     ]
    }
   ],
   "source": [
    "# adição \n",
    "ad = u + v\n",
    "print(ad)\n",
    "\n",
    "# subtração\n",
    "sub = u - v\n",
    "print(sub)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemplo:** $\\bf{A} \\pm \\bf{B}$, com \n",
    "    \n",
    "$${\\bf B} = \n",
    "\\begin{bmatrix}\n",
    "\\vec{u} & 2\\vec{u} & 3\\vec{v} \\\\\n",
    "\\end{bmatrix}$$    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6  4 -5]\n",
      " [-4  0 12]\n",
      " [18 18  0]]\n",
      "[[  0  -8   7]\n",
      " [  0   8 -12]\n",
      " [  0 -18   0]]\n"
     ]
    }
   ],
   "source": [
    "# adição\n",
    "\n",
    "B = np.array([u,2*u,3*v]).T\n",
    "\n",
    "ad2 = A + B\n",
    "print(ad2)\n",
    "\n",
    "sub2 = A - B\n",
    "print(sub2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  2]\n",
      " [ 3  4]]\n",
      "[[-2  4]\n",
      " [ 6  8]]\n",
      "[[0.5 0.5]\n",
      " [0.5 0.5]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[-1,2],[3,4]])\n",
    "print(A)\n",
    "print(2*A)\n",
    "\n",
    "print(A/(2*A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Produto interno\n",
    "\n",
    "O produto interno $\\langle \\vec{u}, \\vec{v}\\rangle$ é computado com `.dot`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-14\n",
      "-4\n"
     ]
    }
   ],
   "source": [
    "pi = np.dot(u,v)\n",
    "print(pi)\n",
    "\n",
    "pi2 = np.dot(np.array([3,1]),np.array([-1,-1]))\n",
    "print(pi2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma segunda forma, mais imediata, emprega o operador infixo `@`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-14\n",
      "-4\n"
     ]
    }
   ],
   "source": [
    "pii = u @ v\n",
    "print(pii)\n",
    "\n",
    "pii2 = np.array([3,1]) @ np.array([-1,-1])\n",
    "print(pii2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Norma de vetor\n",
    "\n",
    "A norma $||\\vec{u}||$ de um vetor $\\vec{u}$ é calculada como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.695359714832659"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(np.dot(u,u))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Produto de matrizes\n",
    "\n",
    "O produto $\\bf{A}\\bf{B}$ entre matrizes bidimensionais pode ser calculado com `np.dot`, mas recomenda-se usar `np.matmul`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 22,  44, -42],\n",
       "       [-14, -28,  60],\n",
       "       [ 27,  54, -54]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# não tem o mesmo efeito para \n",
    "# matrizes A e B de tamanhos arbitrários\n",
    "np.dot(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[25.66666667, 22.        ],\n",
       "       [33.        , 80.66666667]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# uso recomendado para a operação tradicional\n",
    "np.matmul(A,B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Produto entre matriz e vetor\n",
    "\n",
    "Neste caso, sendo ${\\vec{\\vec A}}$ (dois símbolos indicam que a matriz é uma grandeza de ordem 2, ao passo que o vetor é de ordem 1 e aqui usamos para consistência de notação) e ${\\vec{b}}$ uma matriz $m \\times n$ e um vetor $n \\times 1$, respectivamente, o produto $\\vec{\\vec{A}}\\vec{b}$ é dado por:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "shapes (2,2) and (3,) not aligned: 2 (dim 1) != 3 (dim 0)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/ll/g0vl8b194pbfyp4cwpzz4p740000gn/T/ipykernel_13773/88528875.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mb\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marray\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mA\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mb\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m~/opt/anaconda3/lib/python3.9/site-packages/numpy/core/overrides.py\u001b[0m in \u001b[0;36mdot\u001b[0;34m(*args, **kwargs)\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: shapes (2,2) and (3,) not aligned: 2 (dim 1) != 3 (dim 0)"
     ]
    }
   ],
   "source": [
    "b = np.array([3,4,1])\n",
    "\n",
    "np.dot(A,b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Demais operações com `numpy.linalg`\n",
    "\n",
    "Para outras operações, devemos utilizar o submódulo `numpy.linalg`. Para importá-lo com o _alias_ `lin`, fazemos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.linalg as lin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determinante\n",
    "\n",
    "O determinante de ${\\bf A}$ é dado por $\\det({\\bf A})$ e pode ser computado pela função `det`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-10.000000000000002\n"
     ]
    }
   ],
   "source": [
    "# calculando o determinante da matriz\n",
    "det = lin.det(A)\n",
    "print(det)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inversa de uma matriz\n",
    "\n",
    "A inversa de uma matriz é dada por ${\\bf A}^{-1}$, onde ${\\bf A}{\\bf A}^{-1}={\\bf I}$, e ${\\bf I}$ é a matriz identidade.\n",
    "Para usar esta função, devemos fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.00000000e+00 2.22044605e-16 0.00000000e+00]\n",
      " [1.11022302e-16 1.00000000e+00 0.00000000e+00]\n",
      " [0.00000000e+00 0.00000000e+00 1.00000000e+00]]\n"
     ]
    }
   ],
   "source": [
    "B2 = np.array([[1,2,3],\n",
    "              [2,3,4],\n",
    "              [1,2,0]]) \n",
    "\n",
    "B3 = lin.inv(B2)\n",
    "print(np.matmul(B3,B2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Soluções de sistemas lineares\n",
    "\n",
    "Para resolver sistemas lineares, devemos escrever as equações em forma de matriz, ou seja, ${\\vec{\\vec A}}\\vec{x} = \\vec{b}$ e utilizar `solve`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exemplo:** Resolva o sistema linear abaixo:\n",
    "\n",
    "$$\\begin{cases}\n",
    "ax + by = c \\\\ \n",
    "dx + ey = f\n",
    "\\end{cases}$$\n",
    "\n",
    "para $a = -4$, $b = 1$, $c = 1/2$, $d = 3$, $e = 5$ e $f = 10$,  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'np' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m/Users/gustavo/Dropbox/courses/calculo-numerico/LVMN/aula-08a-matrizes-vetores.ipynb Cell 51\u001b[0m in \u001b[0;36m1\n\u001b[0;32m----> <a href='vscode-notebook-cell:/Users/gustavo/Dropbox/courses/calculo-numerico/LVMN/aula-08a-matrizes-vetores.ipynb#Y101sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m A \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([[\u001b[39m-\u001b[39m\u001b[39m4\u001b[39m,\u001b[39m1\u001b[39m],[\u001b[39m3\u001b[39m, \u001b[39m5\u001b[39m]])\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/gustavo/Dropbox/courses/calculo-numerico/LVMN/aula-08a-matrizes-vetores.ipynb#Y101sZmlsZQ%3D%3D?line=2'>3</a>\u001b[0m b \u001b[39m=\u001b[39m np\u001b[39m.\u001b[39marray([\u001b[39m1\u001b[39m\u001b[39m/\u001b[39m\u001b[39m2\u001b[39m,\u001b[39m10\u001b[39m])\n\u001b[1;32m      <a href='vscode-notebook-cell:/Users/gustavo/Dropbox/courses/calculo-numerico/LVMN/aula-08a-matrizes-vetores.ipynb#Y101sZmlsZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39m# solução\u001b[39;00m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'np' is not defined"
     ]
    }
   ],
   "source": [
    "A = np.array([[-4,1],[3, 5]])\n",
    "\n",
    "b = np.array([1/2,10])\n",
    "\n",
    "# solução\n",
    "x = lin.solve(A, b)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Inversa de matriz\n",
    "\n",
    "A inversa de uma matriz (faça esta operação apenas para matrizes quadradas de pequena dimensão) pode ser encontrada como:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-0.24  0.08]\n",
      " [ 0.04  0.32]]\n"
     ]
    }
   ],
   "source": [
    "Ainv = lin.inv(A)\n",
    "print(Ainv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para realizar uma \"prova real\" da solução do sistema anterior, poderíamos fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-0.4  3.4]\n"
     ]
    }
   ],
   "source": [
    "x2 = np.dot(lin.inv(A), b)\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note, entretanto que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([False, False])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x == x2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isto ocorre devido a erros numéricos. Um teste mais adequado deve computar a norma do vetor \"erro\", dado por ${\\bf e} = \\bf{b} - \\bf{A}\\bf{x}$. A norma pode ser calculada diretamente com:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e = b - np.dot(A,x)\n",
    "lin.norm(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isto é, esperamos que $||{\\bf e}|| \\approx 0$ quando a solução do sistema for exata, a menos de erros numéricos."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```{warning}\n",
    "Nunca compare dois números reais (`float`) usando igualdade. Ou seja, `x == y`, não é, em geral, um bom teste lógico para verificar se `x` e `y` possuem o mesmo valor numérico.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Algumas matrizes especiais"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nula\n",
    "\n",
    "Para criar uma matriz nula de ordem _m x n_, usamos `zeros`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m,n = 3,4\n",
    "np.zeros((m,n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Identidade\n",
    "\n",
    "Uma matriz identidade (quadrada) de ordem _p_ é criada com `eye`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0., 0., 0.],\n",
       "       [0., 1., 0., 0.],\n",
       "       [0., 0., 1., 0.],\n",
       "       [0., 0., 0., 1.]])"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "p = 4\n",
    "np.eye(p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matriz de \"uns\"\n",
    "\n",
    "Uma matriz composta apenas de valores 1 de ordem _m x n_ pode ser criada com `ones`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,5))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Triangular inferior\n",
    "\n",
    "A matriz triangular inferior de uma dada matriz pode ser criada com `tril`. Note que podemos também defini-la explicitamente, linha a linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-3.66666667,  0.        ],\n",
       "       [11.        , 14.66666667]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# os valores correspondentes\n",
    "# são zerados\n",
    "np.tril(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Triangular superior\n",
    "\n",
    "A matriz triangular superior de uma dada matriz pode ser criada com `triu`. Note que podemos também defini-la explicitamente, linha a linha."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 3,  6, -6],\n",
       "       [ 0, -4, 12],\n",
       "       [ 0,  0,  0]])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.triu(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercício.** Por que há dois valores `False` no teste a seguir? "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False,  True,  True],\n",
       "       [ True, False,  True],\n",
       "       [ True,  True,  True]])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B == np.tril(B) + np.triu(B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Autovalores e autovetores\n",
    "\n",
    "Um vetor ${\\bf v} \\in V$, ${\\bf v} \\neq {\\bf 0}$ é vetor próprio de ${\\bf A}$ se existir $\\lambda \\in \\mathbb{R}$ tal que \n",
    "\n",
    "$${\\bf Av}=\\lambda {\\bf v}.$$\n",
    "\n",
    "O número real $\\lambda$ é denominado valor próprio (autovalor) de ${\\bf A}$ associado ao vetor próprio (autovetor) ${\\bf v}$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.1400549446402595 -5.1400549446402595\n",
      "[0.99033427 0.13870121]\n",
      "[-0.13870121  0.99033427]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2,1],\n",
    "              [1,-5]])\n",
    "\n",
    "w, v = lin.eig(A)\n",
    "a,b = w\n",
    "\n",
    "# autovalores\n",
    "print(a,b)\n",
    "\n",
    "# autovetor 1\n",
    "print(v[:,0])\n",
    "\n",
    "# autovetor 2\n",
    "print(v[:,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Somas e valores extremos \n",
    "\n",
    "Podemos calcular somas de elementos de matrizes e vetores de maneiras diferentes. Para matrizes, em particular, há soma total, por linha, ou por coluna. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.array([1,-2,-3,10])\n",
    "\n",
    "# soma de todos os elementos \n",
    "np.sum(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# modo alternativo\n",
    "a.sum() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# soma total de matriz\n",
    "O = np.ones((5,3))\n",
    "\n",
    "np.sum(O)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.0"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# modo alternativo\n",
    "O.sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[0, 0],\n",
       "        [0, 0]]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# soma por linha \n",
    "\n",
    "M = np.array( [ [ [ [-1,0],[1,0] ], [ [-1,0],[1,0] ]] ])\n",
    "\n",
    "np.sum(M,axis=2)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3., 3., 3., 3., 3.])"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# soma por coluna \n",
    "np.sum(O,axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Valores máximos e mínimos, absolutos ou não, também podem ser computados com funções simples."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# min\n",
    "np.min(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max\n",
    "np.max(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-3"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# modo alternativo\n",
    "a.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mínimo absoluto \n",
    "np.abs(a).min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# máximo absoluto\n",
    "np.abs(a).max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O2 = np.array([[-4,5],[2,7]])\n",
    "\n",
    "# min\n",
    "np.min(O2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# max \n",
    "np.max(O2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-4"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "O2.min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'O2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/ll/g0vl8b194pbfyp4cwpzz4p740000gn/T/ipykernel_13773/3156693447.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mO2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmax\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'O2' is not defined"
     ]
    }
   ],
   "source": [
    "O2.max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(O2).min()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.abs(O2).max()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}