jupyter_notebooks/explorando_numpy.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NumPy\n",
    "\n",
    "[NumPy](https://numpy.org/) é uma das principais bibliotecas para computação científica em Python. \n",
    "\n",
    "Elas nos provê objetos **arrays multidimensionais** de elevada perfomance e também diversas ferramentas para trabalharmos com eles."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Arrays\n",
    "\n",
    "Um array NumPy é uma grid de valores, todos do mesmo tipo e indexados por uma tupla de inteiros não-negativos. O número de dimensões é o rank do array. A forma do array é uma tupla de inteiros que nos traz o tamanho do array ao longo de cada dimensão.\n",
    "\n",
    "Podemos inicializar os arrays NumPy através de listas Python, e para acessar os seus elementos utilizamos os colchetes.\n",
    "\n",
    "Iniciamos então importando a biblioteca NumPy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Começamos criando um array **a** de rank 1 (1 Dimensão).\n",
    "\n",
    "Perceba que ao utilizarmos o método **type()** no array **a**, ele nos retorna um objeto `<class 'numpy.ndarray'>`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "<class 'numpy.ndarray'>\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3])\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O atributo **shape** nos retorna a forma do array, neste caso, 1 linha e 3 colunas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3,)\n"
     ]
    }
   ],
   "source": [
    "print(a.shape) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, através do do acesso aos índices por colchetes, imprimimos cada um dos elementos do array **a**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(a[0],a[1],a[2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que podemos alterar os elementos do array, neste caso, alteramos o segundo elemento:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 7 3]\n"
     ]
    }
   ],
   "source": [
    "a[1] = 7 \n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, criamos um array **b** de rank 2 (2 Dimensões):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "b = np.array([[1,2,3],[4,5,6]])\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como vimos anteriormente, o atributo **shape** nos retorna a forma do array, neste caso, 2 linhas e 3 colunas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "print(b.shape) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, acessamos alguns elementos:\n",
    "\n",
    "- Elemento da primeira linha e primeira coluna\n",
    "- Elemento da segunda linha e segunda coluna\n",
    "- Elemento da segunda linha e terceira coluna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 5 6\n"
     ]
    }
   ],
   "source": [
    "print(b[0,0], b[1,1], b[1,2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy também nos traz diversas funções para criarmos arrays.\n",
    "\n",
    "**zeros()** cria um array somente de zeros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0. 0.]\n",
      " [0. 0.]]\n"
     ]
    }
   ],
   "source": [
    "c = np.zeros((2,2)) \n",
    "print(c) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ones()** cria um array somente preenchido com o número um:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.]\n",
      " [1.]]\n"
     ]
    }
   ],
   "source": [
    "d = np.ones((2,1)) \n",
    "print(d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**full()** cria um array com um valor constante, neste caso, escolhemos o número 8:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 8 8]\n",
      " [8 8 8]]\n"
     ]
    }
   ],
   "source": [
    "e = np.full((2,3),8) \n",
    "print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**eye()** cria uma matriz identidade de dimensão especificada por nós:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 0. 0.]\n",
      " [0. 1. 0.]\n",
      " [0. 0. 1.]]\n"
     ]
    }
   ],
   "source": [
    "f = np.eye(3) \n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**random()** nos permite criar um array preenchido com números aleatórios:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.3003789  0.4546386 ]\n",
      " [0.51795574 0.0866629 ]]\n"
     ]
    }
   ],
   "source": [
    "g = np.random.random((2,2)) \n",
    "print(g)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Indexando Arrays\n",
    "\n",
    "NumPy nos oferece diversas maneiras de indexarmos os arrays.\n",
    "\n",
    "**Slicing:** Similar às listas de Python, os arrays de NumPy podem ser 'fatiados'. \n",
    "\n",
    "Uma vez que arrays podem ser multidimensionais, é necessário que se especifique uma 'fatia' para cada dimensão do array.\n",
    "\n",
    "Começamos criando o array **a** de rank 2 com forma (3,4):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  3  4  6]\n",
      " [ 2  7  8 11]\n",
      " [12  9 10  5]]\n",
      "(3, 4)\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,3,4,6],[2,7,8,11],[12,9,10,5]])\n",
    "print(a)\n",
    "print(a.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos utilizar a técnica de slicing para obtermos um subarray de apenas as duas primeiras linhas (`:2`) e colunas 2 e 3 (`1:3`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[3 4]\n",
      " [7 8]]\n",
      "(2, 2)\n"
     ]
    }
   ],
   "source": [
    "b = a[:2, 1:3]\n",
    "print(b)\n",
    "print(b.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma 'fatia' de um array é uma visualização dos mesmos dados, então modificando ela, modificará o array original.\n",
    "\n",
    "Observe no exemplo a seguir, que nosso array **a** é alterado ao alterarmos o valor de **b**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "print(a[0,1])\n",
    "b[0,0] = 13\n",
    "print(a[0,1]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nós também podemos misturar a **indexação de inteiros** com a indexação **slicing**. \n",
    "\n",
    "Entretanto, fazer dessa maneira nos produzirá um array de rank menor do que a versão original.\n",
    "\n",
    "Começamos criando o array **a** de rank 2 com forma (3,4):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[12 11 10  9]\n",
      " [ 8  7  6  5]\n",
      " [ 4  3  2  1]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[12,11,10,9],[8,7,6,5],[4,3,2,1]])\n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Duas maneiras de acessarmos os dados da linha do meio do array:\n",
    "\n",
    "- Misturando indexação de inteiros com a indexação slicing produzirá um array de rank menor\n",
    "- Se usarmos apenas slicing, produzirá produzirá um array do mesmo rank do original"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualização Rank 1 da segunda linha do array **a**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8 7 6 5] (4,)\n"
     ]
    }
   ],
   "source": [
    "linha_l1 = a[1, :]\n",
    "print(linha_l1, linha_l1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualização Rank 2 da segunda linha do array **a**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[8 7 6 5]] (1, 4)\n"
     ]
    }
   ],
   "source": [
    "linha_l2 = a[1:2, :]\n",
    "print(linha_l2, linha_l2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A mesma distinção pode se aplicar quando acessarmos as colunas do array.\n",
    "\n",
    "Visualização Rank 1 da segunda coluna do array **a**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11  7  3] (3,)\n"
     ]
    }
   ],
   "source": [
    "col_c1 = a[:, 1]\n",
    "print(col_c1, col_c1.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualização Rank 2 da segunda coluna do array **a**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11]\n",
      " [ 7]\n",
      " [ 3]] (3, 1)\n"
     ]
    }
   ],
   "source": [
    "col_c2 = a[:, 1:2]\n",
    "print(col_c2, col_c2.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexação de Arrays por Inteiros:** Quando nós indexamos os arrays NumPy utilizando o método de **slicing** o array resultante será um subarray do original. Em contraste, indexação de array por inteiros nos permite construir arrays arbitrários utilizando dados de outros arrays.\n",
    "\n",
    "Para entender a ideia, vamos criar um novo array **a**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um exemplo de indexação de arrays por inteiros, o array retornado terá a forma (3,):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(a[[0, 1, 2], [0, 1, 0]])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O exemplo a seguir é equivalente ao de cima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 4 5]\n"
     ]
    }
   ],
   "source": [
    "print(np.array([a[0, 0], a[1, 1], a[2, 0]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando utilizamos a indexação de arrays por inteiros, podemos reutilizar o mesmo elemento do array principal:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "print(a[[0, 0], [1, 1]]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O exemplo a seguir é equivalente ao de cima:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2 2]\n"
     ]
    }
   ],
   "source": [
    "print(np.array([a[0, 1], a[0, 1]]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma técnica muito interessante em relação à **indexação de arrays por inteiros** é a seleção ou mutação de um elemento para cada linha do array.\n",
    "\n",
    "Novamente vamos criar um array **a** no qual selecionaremos elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(a) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, criamos um array **b** de índices:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = np.array([0, 2, 0, 1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Selecionamos um elemento de cada linha de **a** utilizando os índices de **b**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 1  6  7 11]\n"
     ]
    }
   ],
   "source": [
    "print(a[np.arange(4), b]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Mutamos um elemento para cada linha de **a** utilizando os índices de **b**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11  2  3]\n",
      " [ 4  5 16]\n",
      " [17  8  9]\n",
      " [10 21 12]]\n"
     ]
    }
   ],
   "source": [
    "a[np.arange(4), b] += 10\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Indexação de arrays Booleana:** Indexação de arrays booleana nos permite escolher elementos arbitrários de um array. Frequentemente esse tipo de indexação é utilizada para selecionar os elementos de um array que satisfaça determinada condição. \n",
    "\n",
    "Veja um exemplo com o array **a** que vamos criar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]\n",
      " [5 6]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1,2], [3, 4], [5, 6]])\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O índice booleano a seguir busca os elementos de **a** que são maiores que **2** e nos retorna um array NumPy de booleanos da mesma forma de **a**, onde cada slot de **bool_idx** nos diz se aquele elemento de **a** é maior do que **2**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[False False]\n",
      " [ True  True]\n",
      " [ True  True]]\n"
     ]
    }
   ],
   "source": [
    "bool_idx = (a > 2)\n",
    "print(bool_idx)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Utilizamos a indexação de arrays booelana para construir um array de rank 1 que consiste dos elementos correspondentes aos valores **True** de **bool_idx**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(a[bool_idx]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nós também podemos fazer tudo que foi feito acima em um única e concisa declaração:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "print(a[a > 2]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tipos de Dados\n",
    "\n",
    "Todo array NumPy é uma grid de elementos do mesmo tipo. \n",
    "\n",
    "NumPy oferece um grande conjunto de tipos de dados numéricos que nós podemos utilizar para construir arrays. \n",
    "\n",
    "NumPy tenta adivinhar o tipo de dados quando criamos o array, porém funções que constroem arrays normalmente também incluem um argumento opcional que define explicitamente o tipo de dados. \n",
    "\n",
    "A seguir, criamos um array e deixamos NumPy inferir o tipo de dados dele:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2])   \n",
    "print(x.dtype)     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente, criamos outros array e deixamos NumPy inferir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "float64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1.0, 2.0])  \n",
    "print(x.dtype)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos 'forçar' um tipo de dados particular de nossa escolha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "int64\n"
     ]
    }
   ],
   "source": [
    "x = np.array([1, 2], dtype=np.int64)  \n",
    "print(x.dtype)   "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matemática com Arrays\n",
    "\n",
    "Funções matemáticas básicas operam em cada elemento do array e estão disponíveis como sobrecarga de operador e como funções no módulo NumPy.\n",
    "\n",
    "Vamos definir dois arrays: **x** e **y** e realizaremos algumas operações com eles:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2.]\n",
      " [3. 4.]]\n",
      "[[5. 6.]\n",
      " [7. 8.]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]], dtype=np.float64)\n",
    "y = np.array([[5,6],[7,8]], dtype=np.float64)\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem duas formas de realizar a soma de cada elemento dos arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "print(x + y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 6.  8.]\n",
      " [10. 12.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.add(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem duas formas de realizar a subtração de cada elemento dos arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "print(x - y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-4. -4.]\n",
      " [-4. -4.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.subtract(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem duas formas de realizar a multiplicação de cada elemento dos arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "print(x * y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5. 12.]\n",
      " [21. 32.]]\n"
     ]
    }
   ],
   "source": [
    "print(np.multiply(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Existem duas formas de realizar a divisão de cada elemento dos arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "print(x / y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.2        0.33333333]\n",
      " [0.42857143 0.5       ]]\n"
     ]
    }
   ],
   "source": [
    "print(np.divide(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também extrair a raiz quadrada de cada elemento de **x**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         1.41421356]\n",
      " [1.73205081 2.        ]]\n"
     ]
    }
   ],
   "source": [
    "print(np.sqrt(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante destacarmos que diferente do MATLAB, `*` é uma multiplicação de cada elemento, não uma multiplicação de matriz. \n",
    "\n",
    "Em vez disso, usamos a função **dot** para computarmos o produto escalar dos vetores por uma matriz, e também para multiplicarmos matrizes. \n",
    "\n",
    "**dot** está disponível como uma função no módulo NumPy e como uma método instância dos objetos array.\n",
    "\n",
    "Vamos criar duas matrizes **x** e **y** e dois vetores **v** e **w** para este exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "[[5 6]\n",
      " [7 8]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "y = np.array([[5,6],[7,8]])\n",
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 9 10] [11 12]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([9,10])\n",
    "w = np.array([11, 12])\n",
    "print(v,w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produto escalar dos vetores, equivalentes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "219\n",
      "219\n"
     ]
    }
   ],
   "source": [
    "print(v.dot(w))\n",
    "print(np.dot(v, w))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produto escalar matriz e vetor, equivalentes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[29 67]\n",
      "[29 67]\n"
     ]
    }
   ],
   "source": [
    "print(x.dot(v))\n",
    "print(np.dot(x, v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Produto escalar matriz e matriz, equivalentes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[19 22]\n",
      " [43 50]]\n",
      "[[19 22]\n",
      " [43 50]]\n"
     ]
    }
   ],
   "source": [
    "print(x.dot(y))\n",
    "print(np.dot(x, y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NumPy nos provê diversas funções úteis para executarmos computações em arrays: uma das mais úteis é **sum**, capaz de computar a soma dos elementos do array de várias maneiras diferentes.\n",
    "\n",
    "Vamos definir um array **x** experimental para compreendermos o funcionamento de **sum**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2],[3,4]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, computamos a soma de todos os elementos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, computamos a soma de cada coluna:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4 6]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(x, axis=0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, computamos a soma de cada linha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3 7]\n"
     ]
    }
   ],
   "source": [
    "print(np.sum(x, axis=1)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Além de computar funções matemáticas utilizando arrays, nós frequentemente necessitamos alterar a forma ou então manipular os dados nos arrays.\n",
    "\n",
    "O exemplo mais simples desse tipo de operação é a transposição de uma matriz; para transpor uma matriz, simplesmente utilizamos o atributo **T** de um objeto array.\n",
    "\n",
    "Novamente, definimos dois novos arrays **x** e **v** para o exemplo."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2], [3,4]])\n",
    "print(x) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fazemos a transposição de **x**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3]\n",
      " [2 4]]\n"
     ]
    }
   ],
   "source": [
    "print(x.T) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Definimos o vetor **v**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3])\n",
    "print(v) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perceba agora que ao transpor um array **v** de rank 1 não ocorre nada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n"
     ]
    }
   ],
   "source": [
    "print(v.T) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Broadcasting\n",
    "\n",
    "**Broadcasting** é um mecanismo poderoso que permite NumPy trabalhar com arrays de diferentes formas quando estiver realizando operações aritméticas. \n",
    "\n",
    "Frequentemente nós temos um array menor e um array maior e nós desejamos usar o array menor múltiplas vezes para realizarmos algumas operações no array maior.\n",
    "\n",
    "Por exemplo, vamos supor que nós desejamos adicionar um vetor constante para cada linha da matriz. \n",
    "\n",
    "Podemos fazer da seguinte maneira."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nós vamos adicionar o vetor **v** para cada linha da matriz **x**, guardando o resultado na matriz **y**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 0 1]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1, 0, 1])\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método **empty_like** cria uma matriz vazia da mesma forma de **x**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n"
     ]
    }
   ],
   "source": [
    "y = np.empty_like(x)  \n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em seguida, adicionamos o vetor **v** para cada linha da matriz **x** com um loop explícito:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "for i in range(4):\n",
    "    y[i, :] = x[i, :] + v\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perceba que funciona como esperado, entretanto quando a matriz **x** é muito grande, computar um loop explícito em Python pode se tornar um processo lento. \n",
    "\n",
    "Perceba que adicionar o vetor **v** para cada linha da matriz **x** é equivalente a formar uma matriz **vv** empilhando múltiplas cópias de **v** verticalmente e então executando a soma de cada elemento de **x** e **vv**. \n",
    "\n",
    "Nós podemos implementar essa abordagem da seguinte forma."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nós adicionaremos o vetor **v** para cada linha da matriz **x** guardando o resultado na matriz **y**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "[1 0 1]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "print(x)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O método **tile** empilha 4 cópias do vetor **v**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]\n",
      " [1 0 1]]\n"
     ]
    }
   ],
   "source": [
    "vv = np.tile(v, (4, 1)) \n",
    "print(vv)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E então adicionamos cada elemento de **x** e **vv**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + vv\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Broadcasting** em NumPy nos permite realizar essa computação sem a necessidade de criarmos múltiplas cópías de **v**. \n",
    "\n",
    "Considere essa versão, utilizando o conceito de **broadcasting**.\n",
    "\n",
    "Nós iremos adicionar o vetor **v** para cada linha da matriz **x**, guardando o resultado na matriz **y**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 1  2  3]\n",
      " [ 4  5  6]\n",
      " [ 7  8  9]\n",
      " [10 11 12]]\n",
      "[1 0 1]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3], [4,5,6], [7,8,9], [10, 11, 12]])\n",
    "v = np.array([1, 0, 1])\n",
    "print(x)\n",
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A seguir, adicionamos **v** para cada linha de **x** usando broadcasting:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  2  4]\n",
      " [ 5  5  7]\n",
      " [ 8  8 10]\n",
      " [11 11 13]]\n"
     ]
    }
   ],
   "source": [
    "y = x + v\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A linha **y = x + v** funciona apesar de **x** ter a forma **(4, 3)** e **v** ter a forma **(3,)**, isso por causa do broadcasting; essa linha funciona como se **v** tivesse a forma **(4,3)**, onde cada linha é uma cópia de **v** e a soma é realizada para cada elemento.\n",
    "\n",
    "Broadcasting de dois arrays juntos segue as seguintes regras:\n",
    "\n",
    "1. Se os arrays não tiverem o mesmo rank, pré-acrescenta-se a forma do array de rank menor com 1's até que ambas as formas tenham a mesma extensão.\n",
    "2. Os dois arrays são ditos compatíveis em uma dimensão se eles tiverem o mesmo tamanho na dimensão, ou se algum dos arrays tiver tamanho 1 naquela dimensão.\n",
    "3. O broadcast pode ser feito nos arrays juntos se eles forem compatíveis em todas as dimensões.\n",
    "4. Depois do broadcast, cada array se comporta como se ele tivesse sua forma igual ao máximo de formas de cada elemento dos dois arrays de input.\n",
    "5. Em cada dimensão onde um array tem o tamanho 1 e o outro array tem o tamanho maior do que 1, o primeiro array se comporta como se ele tivesse sido copiado juntamente àquela dimensão.\n",
    "\n",
    "Vejamos algumas aplicações práticas do broadcasting."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Computando o produto exterior dos vetores **v** e **w**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "[4 5]\n"
     ]
    }
   ],
   "source": [
    "v = np.array([1,2,3])\n",
    "w = np.array([4,5])\n",
    "print(v)\n",
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para computarmos o produto exterior, primeiro alteramos a forma de **v** para ser uma coluna, ou seja, um vetor de forma (3, 1); nós então podemos fazer o broadcast em **w** para produzir um output de forma (3, 2), no qual é o produto exterior de **v** e **w**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 4  5]\n",
      " [ 8 10]\n",
      " [12 15]]\n"
     ]
    }
   ],
   "source": [
    "print(np.reshape(v, (3, 1)) * w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adicionando um vetor para cada linha da matriz **x**:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3]\n",
      " [4 5 6]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3], [4,5,6]])\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**x** tem a forma (2, 3) e **v** tem a forma (3,) então o broadcast fica (2, 3):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 4 6]\n",
      " [5 7 9]]\n"
     ]
    }
   ],
   "source": [
    "print(x + v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Adicionando um vetor para cada coluna da matriz **x**.\n",
    "\n",
    "**x** tem a forma (2, 3) e **w** tem a forma (2,).\n",
    "\n",
    "Se nós transpormos **x** então ele terá a forma (3,2) e pode ser feito o broadcast em **w** para produzir o resultado de forma (3,2), transpondo esse resultado produz a forma final de (2,3) no qual é a matriz **x** com o vetor **w** adicionado para cada coluna, resultando a seguinte matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "print((x.T + w).T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outra solução é alterar a forma de **w** para ser um vetor de colunas de forma (2,1).\n",
    "\n",
    "Nós então podemos fazer o broadcast dele diretamente contra **x** para o produzir o mesmo output:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 5  6  7]\n",
      " [ 9 10 11]]\n"
     ]
    }
   ],
   "source": [
    "print(x + np.reshape(w, (2, 1)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multiplicar uma matriz por uma constante:\n",
    "\n",
    "**x** tem a forma (2,3). NumPy trata escalares como arrays de forma (); estes podem ser feito o broadcast juntos para formar (2,3), produzindo o seguinte array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 2  4  6]\n",
      " [ 8 10 12]]\n"
     ]
    }
   ],
   "source": [
    "print(x * 2)"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}