{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Estudando a Biblioteca Numpy\n",
    "#### Neste notebook, vamos analisar algumas funções pertencentes a biblioteca numpy. É pertinente saber que tal biblioteca nos permite implementar ótimas aplicações computacionais em Àlgebra Linear e, através dela, reduzir o nosso trabalho em diversas situações na qual o cálculo feito de forma manual seja algo maçante."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Importando a Biblioteca"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# importando a biblioteca de funções do python\n",
    "import numpy as np "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando uma Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# iniciando um array em python\n",
    "M = np.array([10,24,34,45,56]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Verificando o Tipo da Variável"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# mostra o tipo da variável a qual a função type recebe\n",
    "type(M) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Formas de Imprimir Dados na Tela\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pode-se imprimir algum tipo de dado dessa forma\n",
    "type(M) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 24, 34, 45, 56])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# digitar a variável no Jupyter Notebook também nos permite ver o seu conteúdo\n",
    "M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 24 34 45 56]\n"
     ]
    }
   ],
   "source": [
    "# colocar uma variável diretamente também é um formato compilável\n",
    "print(M) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Trabalhando com Elementos da Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# atente-se que na progamação, na maioria das linguagens temos um array \n",
    "# iniciado no elemento [0][0] \n",
    "print(\"{}\".format(M[0])) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56\n"
     ]
    }
   ],
   "source": [
    "# aqui vemos o elemento 4, na terceira possição do array\n",
    "print(\"{}\".format(M[4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 24 34 45]\n"
     ]
    }
   ],
   "source": [
    "# mostra todos os elementos do array começando na posição zero até a terceira posição\n",
    "# atente-se que o último elemento de parada não é considerado no cálculo, e sim o seu antecessor\n",
    "print(\"{}\".format(M[0:4])) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dimensões da Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5,)\n"
     ]
    }
   ],
   "source": [
    "# função que mostra a dimensão do array\n",
    "# (linhas, colunas)\n",
    "print(M.shape) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matrizes de Tamanhos Diversos (arrays multidimensionais)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando um array multidimensional\n",
    "MD = np.array([[1,2,3,4,5],[6,7,8,9,10]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4  5]\n",
      " [ 6  7  8  9 10]]\n"
     ]
    }
   ],
   "source": [
    "# imprime o array multidimensional\n",
    "print(\"{}\".format(MD)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 5)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# verificando a dimensão do array\n",
    "MD.shape "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# forma de verificar os elementos da matriz multidimensional\n",
    "MD[1,1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outra forma de verificar os elementos da matriz multidimensional\n",
    "MD[1][1] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# o parâmetro de entrada zero permitirá ver a quantidade de linhas do array\n",
    "MD.shape[0] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# o parâmetro de entrada um permitirá ver a quantidade de colunas do array\n",
    "MD.shape[1] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando uma Submatriz de Outra Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "# subMD recebe as linhas localizadas na posição zero e um, e colunas de zero a dois\n",
    "# atente-se que o último digito de parada é desconsiderado\n",
    "subMD = MD[0:2, 0:3] "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [6 7 8]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz subMD\n",
    "print(\"{}\".format(subMD)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Modificando Elementos das Matrizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "# nova entrada para o elemento da matriz localizado na posição MD[1][1]\n",
    "MD[1,1] = 11 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3  4  5]\n",
      " [ 6 11  8  9 10]]\n"
     ]
    }
   ],
   "source": [
    "# veja como o elemento da matriz na posição [1][1] foi modificado\n",
    "print(\"{}\".format(MD)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Transformando uma Matriz de Números Inteiros em Números Reais"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# o fato do primeiro elemento ser um float, número real, indica que todos os outros elementos \n",
    "# serão também do tipo float\n",
    "MR = np.array([[1.0,2,3,4,5], [1000,12,4556,788,1], [6,7,8,9,1000]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.000e+00 2.000e+00 3.000e+00 4.000e+00 5.000e+00]\n",
      " [1.000e+03 1.200e+01 4.556e+03 7.880e+02 1.000e+00]\n",
      " [6.000e+00 7.000e+00 8.000e+00 9.000e+00 1.000e+03]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz MR\n",
    "# Os valores dos elementos da matriz são mostrados no formato de notação científica computacional\n",
    "print(\"{}\".format(MR))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando uma Matriz Identidade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#observe que a matriz identidade será do tipo float\n",
    "# o parâmetro de entrada é a ordem da matriz a ser trabalhada\n",
    "I = np.eye(4) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0. 0.]\n",
      " [0. 1. 0. 0.]\n",
      " [0. 0. 1. 0.]\n",
      " [0. 0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz Identidade I\n",
    "print(\"{}\".format(I)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando uma Matriz de Zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "# interessante para inicializar uma matriz sem lixo de memória\n",
    "# são dois parâmetros de entrada, relativos a quantidade de linhas e colunas, respectivamente.\n",
    "# caso tal matriz seja manipulada por algum procedimento de multiplicação, essa inicialização \n",
    "# não é uma boa escolha\n",
    "Z = np.zeros((4,4)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]\n",
      " [0. 0. 0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "# imprimindo a matriz Z\n",
    "print(\"{}\".format(Z)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Criando uma Matriz de Uns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mesma ideia da função acima, mas ao invés de zeros, será preenchido com valores 1\n",
    "# observe que essa matriz é ideal quando trabalha-se com operações de multiplicação\n",
    "U = np.ones((4,2)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz U\n",
    "print(\"{}\".format(U)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]\n",
      " [1. 1.]]\n"
     ]
    }
   ],
   "source": [
    "# multiplicando uma matriz com todos os elementos iniciados com 1 por um escalar\n",
    "print(\"{}\".format(U)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# função que cria um array em que todos os seus elementos são iguais a uma constante a ser definida\n",
    "# np.full((número de linhas, número de colunas), constante a ser definida na matriz)\n",
    "U = np.full((5,2), 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[10 10]\n",
      " [10 10]\n",
      " [10 10]\n",
      " [10 10]\n",
      " [10 10]]\n"
     ]
    }
   ],
   "source": [
    "#imprime a matriz U\n",
    "print(\"{}\".format(U)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matriz Randômica"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "# np.random.random((número de linhas, número de colunas))\n",
    "# cria uma matriz de números aleatórios\n",
    "R = np.random.random((4,5)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.83670313 0.6563392  0.77275586 0.69965855 0.55071841]\n",
      " [0.51802409 0.62063839 0.35390263 0.80153205 0.32365402]\n",
      " [0.20997078 0.58628487 0.03465468 0.19432512 0.18718823]\n",
      " [0.33339079 0.02659723 0.22485586 0.58804561 0.71405599]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz R\n",
    "print(\"{}\".format(R)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Média dos Elementos da Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando uma matriz X\n",
    "X = np.array([[1,2,3],[4,5,6]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calcula a média de todos os elementos da matriz X inicializada acima\n",
    "np.mean(X) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operações com Matrizes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando uma matriz A\n",
    "A = np.array([[1,2,3],[4,5,6],[7,8,9]]) \n",
    "# criando uma matriz B\n",
    "B = np.array([[-1,0,1],[0,1,1],[4,4,4]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz A\n",
    "print(\"{}\".format(A)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1  0  1]\n",
      " [ 0  1  1]\n",
      " [ 4  4  4]]\n"
     ]
    }
   ],
   "source": [
    "# imprime a matriz B\n",
    "print(\"{}\".format(B)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1,  0,  3],\n",
       "       [ 0,  5,  6],\n",
       "       [28, 32, 36]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplicação simples de uma matriz\n",
    "# OBS: só é permitido a entrada de matrizes de mesma ordem\n",
    "A * B "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [ 4,  6,  7],\n",
       "       [11, 12, 13]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# soma duas matrizes de mesma ordem\n",
    "A + B "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 2, 2],\n",
       "       [4, 4, 5],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subtração de duas matrizes de mesma ordem\n",
    "A - B "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2, -2, -2],\n",
       "       [-4, -4, -5],\n",
       "       [-3, -4, -5]])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subtração de duas matrizes de mesma ordem\n",
    "B - A "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">Podemos realizar operações utilizando a biblioteca do numpy. Um motivo para essa escolha é que podemos realizar multiplicações com matrizes de ordens diferentes, mas definidas na operação. Além disso, pode-se mudar o tipo de dados trabalhados na matriz e ainda especificar a quantidade de bytes suportadas para armazenamento de cada elemento da mesma. (Dependência dos requisitos da máquina trabalhada, mas em geral: 16 - 128 bytes)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-1.,  0.,  3.],\n",
       "       [ 0.,  5.,  6.],\n",
       "       [28., 32., 36.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# multiplicação de matrizes de ordem diferentes, mas com a multiplicação definida\n",
    "np.multiply(A,B, dtype = float) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0.,  2.,  4.],\n",
       "       [ 4.,  6.,  7.],\n",
       "       [11., 12., 13.]], dtype=float16)"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# soma as matrizes de mesma ordem\n",
    "np.add(A,B, dtype = np.float16) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 2, 2],\n",
       "       [4, 4, 5],\n",
       "       [3, 4, 5]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subtrai as matrizes de mesma ordem\n",
    "np.subtract(A,B, dtype = np.int32) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2, -2, -2],\n",
       "       [-4, -4, -5],\n",
       "       [-3, -4, -5]])"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# subtrai as matrizes de mesma ordem\n",
    "np.subtract(B,A, dtype = np.int32) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz A\n",
    "A = np.array([[1,2,3],[4,5,6]]) \n",
    "# criando a matriz B\n",
    "B = np.array([[1],[1],[1]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6],\n",
       "       [15]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outra função que realiza a multiplicação de matrizes de ordens diferentes, mas \n",
    "# sem especificador de tipo\n",
    "np.matmul(A,B) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 2 is different from 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-50-7bc42922f4c7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# Matriz com operação não definida, veja que a compilação não ocorrerá\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mnp\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mmatmul\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mB\u001b[0m\u001b[1;33m,\u001b[0m\u001b[0mA\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m: matmul: Input operand 1 has a mismatch in its core dimension 0, with gufunc signature (n?,k),(k,m?)->(n?,m?) (size 2 is different from 1)"
     ]
    }
   ],
   "source": [
    "# Matriz com operação não definida, veja que a compilação não ocorrerá\n",
    "np.matmul(B,A) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Cuidado, pois mesmo o código estando digitado corretamente, operações matemáticas podem não estar definidas, resultando em erros fatais ou não fatais pelo compilador."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6],\n",
       "       [15]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outra forma de multiplicar duas matrizes\n",
    "np.dot(A,B) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz a\n",
    "a = np.array([[1,2,3]]) \n",
    "# criando a matriz b\n",
    "b = np.array([[4,5,6]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[32]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Um produto interno é uma generalização do produto escalar. Em um espaço vetorial, \n",
    "# é uma maneira de multiplicar vetores \n",
    "# juntos, com o resultado dessa multiplicação sendo um escalar.\n",
    "np.inner(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz A\n",
    "A = np.array([[1,2,3],[3,4,5]]) \n",
    "# criando a matriz B\n",
    "B = np.array([[1,5,7],[5,9,9]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(128)"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# produto tensorial de dois espaços vetoriais\n",
    "np.tensordot(A,B) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz A\n",
    "A = np.array([[1,2,7],[3,6,7],[8,9,0]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[123235, 185759, 175273],\n",
       "       [205065, 300027, 255535],\n",
       "       [221333, 307524, 210945]])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# função responsável por calcular a potenciação de matrizes.\n",
    "# Nesse caso, A está elevada a 5º potência\n",
    "np.linalg.matrix_power(A,5) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Produto Kronecker"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz A\n",
    "A = np.array([[1,2],[3,4]]) \n",
    "# criando a matriz B\n",
    "B = np.array([[0,5],[6,7]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  5,  0, 10],\n",
       "       [ 6,  7, 12, 14],\n",
       "       [ 0, 15,  0, 20],\n",
       "       [18, 21, 24, 28]])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calcula o produto kronecker de duas matrizes\n",
    "np.kron(A,B) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fatoração de Cholesky"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz A\n",
    "A = np.array([[4,12,-16],[12,37,-43],[-16,-43,98]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [],
   "source": [
    "# função responsável por calcular a fatoração de cholesky\n",
    "fatorada = np.linalg.cholesky(A) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.,  0.,  0.],\n",
       "       [ 6.,  1.,  0.],\n",
       "       [-8.,  5.,  3.]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprime a matriz A\n",
    "fatorada "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[  4.,  12., -16.],\n",
       "       [ 12.,  37., -43.],\n",
       "       [-16., -43.,  98.]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# provando a validade da Fatoração de Cholesky em python\n",
    "# multiplica a matriz fatorada por sua transposta, obtendo a matriz A que foi fatorada\n",
    "np.matmul(fatorada,fatorada.transpose()) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando uma matriz A\n",
    "A = np.array([[2,0],[0,1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 0],\n",
       "       [0, 1]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprime a matriz A\n",
    "A "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autovalores e Autovetores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "#determinando autovalores e autovetores\n",
    "autovalores, autovetores = np.linalg.eig(A) \n",
    "# matriz diagonal de autovalores\n",
    "matrizDiagonal = np.diag(autovalores) \n",
    "\n",
    "# obtendo novamente a matriz A através da decomposição espectral ou valores singulares\n",
    "# A = PDP^(-1)\n",
    "A = np.matmul(np.matmul(autovetores,matrizDiagonal),np.linalg.inv(autovetores)) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# autovetores da matriz A\n",
    "autovetores "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matriz diagonal\n",
    "matrizDiagonal "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# matriz de transformação linear\n",
    "A "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 1.])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# autovalores para a matriz A\n",
    "autovalores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 1.])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# outra forma de se obter os autovalores\n",
    "np.linalg.eigvals(A) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Decomposição em Valores Singulares"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando uma matriz A\n",
    "A = np.array([[2,0],[0,1]]) \n",
    "(U,s,V) = np.linalg.svd(A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#  imprime a matriz U \n",
    "U"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 1.])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprime a matriz s\n",
    "s "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 0.],\n",
       "       [0., 1.]])"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprime a matriz V\n",
    "V "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Determinante de Matrizes\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# determinante da matriz\n",
    "np.linalg.det(A) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Posto da Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# posto da matriz\n",
    "np.linalg.matrix_rank(A) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Traço da Matriz (Soma da Diagonal)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# traço da matriz (soma da diagonal)\n",
    "np.trace(A) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sistema de Equações"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Vamos considerar Ax = B\n",
    "\n",
    "# criando a matriz A\n",
    "A = np.array([[3], [4]])\n",
    "# criando a matriz b\n",
    "b = np.array([[6], [8]])\n",
    "\n",
    "# 3x = 6\n",
    "# 4y = 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "# realiza a multiplicação da matriz inversa de A com a matriz b\n",
    "X = np.matmul(np.linalg.pinv(A), b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.]])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprime a matriz X\n",
    "X "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Matriz Inversa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [],
   "source": [
    "# criando a matriz A\n",
    "A = np.array([[1,2],[3,4]]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-2. ,  1. ],\n",
       "       [ 1.5, -0.5]])"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# imprime a matriz inversa\n",
    "np.linalg.pinv(A) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alguma Dúvida? Entre em Contato Comigo:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- [Me envie um e-mail](mailto:alysson.barbosa@ee.ufcg.edu.br);"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}