notebooks/aula3.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Aula 3 - NumPy e SciPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A parte do numpy tem como principal base o guia oficial do usuário disponibilizado gratuitamente [aqui](https://docs.scipy.org/doc/numpy/numpy-user-1.16.1.pdf).\n",
    "\n",
    "Observação: As notas a seguir estão em constante desenvolvimento, aperfeiçoamento e revisões."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Conteúdo<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Pré-requisitos\" data-toc-modified-id=\"Pré-requisitos-1\"><span class=\"toc-item-num\">1&nbsp;&nbsp;</span>Pré-requisitos</a></span><ul class=\"toc-item\"><li><span><a href=\"#Instalação-do-conda-(Miniconda)\" data-toc-modified-id=\"Instalação-do-conda-(Miniconda)-1.1\"><span class=\"toc-item-num\">1.1&nbsp;&nbsp;</span>Instalação do conda (Miniconda)</a></span></li><li><span><a href=\"#Utilizando-e-instalando-ambientes-(envs)\" data-toc-modified-id=\"Utilizando-e-instalando-ambientes-(envs)-1.2\"><span class=\"toc-item-num\">1.2&nbsp;&nbsp;</span>Utilizando e instalando ambientes (envs)</a></span></li></ul></li><li><span><a href=\"#NumPy\" data-toc-modified-id=\"NumPy-2\"><span class=\"toc-item-num\">2&nbsp;&nbsp;</span>NumPy</a></span><ul class=\"toc-item\"><li><span><a href=\"#O-que-é?\" data-toc-modified-id=\"O-que-é?-2.1\"><span class=\"toc-item-num\">2.1&nbsp;&nbsp;</span>O que é?</a></span></li><li><span><a href=\"#Conceitos-básicos\" data-toc-modified-id=\"Conceitos-básicos-2.2\"><span class=\"toc-item-num\">2.2&nbsp;&nbsp;</span>Conceitos básicos</a></span><ul class=\"toc-item\"><li><span><a href=\"#Importando-o-pacote\" data-toc-modified-id=\"Importando-o-pacote-2.2.1\"><span class=\"toc-item-num\">2.2.1&nbsp;&nbsp;</span>Importando o pacote</a></span></li><li><span><a href=\"#Tipo-básico:-numpy.ndarray\" data-toc-modified-id=\"Tipo-básico:-numpy.ndarray-2.2.2\"><span class=\"toc-item-num\">2.2.2&nbsp;&nbsp;</span>Tipo básico: <code>numpy.ndarray</code></a></span><ul class=\"toc-item\"><li><span><a href=\"#Inicializando\" data-toc-modified-id=\"Inicializando-2.2.2.1\"><span class=\"toc-item-num\">2.2.2.1&nbsp;&nbsp;</span>Inicializando</a></span></li><li><span><a href=\"#Inicializando-arrays-preenchidos-com-zeros-ou-um\" data-toc-modified-id=\"Inicializando-arrays-preenchidos-com-zeros-ou-um-2.2.2.2\"><span class=\"toc-item-num\">2.2.2.2&nbsp;&nbsp;</span>Inicializando arrays preenchidos com zeros ou um</a></span></li><li><span><a href=\"#Atributos-básicos\" data-toc-modified-id=\"Atributos-básicos-2.2.2.3\"><span class=\"toc-item-num\">2.2.2.3&nbsp;&nbsp;</span>Atributos básicos</a></span></li></ul></li></ul></li><li><span><a href=\"#Operações-e-utilitários-básicos\" data-toc-modified-id=\"Operações-e-utilitários-básicos-2.3\"><span class=\"toc-item-num\">2.3&nbsp;&nbsp;</span>Operações e utilitários básicos</a></span><ul class=\"toc-item\"><li><span><a href=\"#Criação-de-arrays-a-partir-de-intervalos:\" data-toc-modified-id=\"Criação-de-arrays-a-partir-de-intervalos:-2.3.1\"><span class=\"toc-item-num\">2.3.1&nbsp;&nbsp;</span>Criação de arrays a partir de intervalos:</a></span></li><li><span><a href=\"#Operações-aritméticas\" data-toc-modified-id=\"Operações-aritméticas-2.3.2\"><span class=\"toc-item-num\">2.3.2&nbsp;&nbsp;</span>Operações aritméticas</a></span></li><li><span><a href=\"#Comentários-sobre-operações-com-tipos-de-dados-distintos\" data-toc-modified-id=\"Comentários-sobre-operações-com-tipos-de-dados-distintos-2.3.3\"><span class=\"toc-item-num\">2.3.3&nbsp;&nbsp;</span>Comentários sobre operações com tipos de dados distintos</a></span></li></ul></li><li><span><a href=\"#Funções-universais-da-NumPy\" data-toc-modified-id=\"Funções-universais-da-NumPy-2.4\"><span class=\"toc-item-num\">2.4&nbsp;&nbsp;</span>Funções universais da NumPy</a></span></li><li><span><a href=\"#Alguns-métodos-de-numpy.ndarray-úteis\" data-toc-modified-id=\"Alguns-métodos-de-numpy.ndarray-úteis-2.5\"><span class=\"toc-item-num\">2.5&nbsp;&nbsp;</span>Alguns métodos de <code>numpy.ndarray</code> úteis</a></span><ul class=\"toc-item\"><li><span><a href=\"#Valores-máximos-e-mínimos-em-um-array\" data-toc-modified-id=\"Valores-máximos-e-mínimos-em-um-array-2.5.1\"><span class=\"toc-item-num\">2.5.1&nbsp;&nbsp;</span>Valores máximos e mínimos em um array</a></span></li><li><span><a href=\"#Somatório-e-produtórios-dos-valores-em-um-array\" data-toc-modified-id=\"Somatório-e-produtórios-dos-valores-em-um-array-2.5.2\"><span class=\"toc-item-num\">2.5.2&nbsp;&nbsp;</span>Somatório e produtórios dos valores em um array</a></span></li><li><span><a href=\"#E-o-que-acontece-em-arrays-multidimensionais?\" data-toc-modified-id=\"E-o-que-acontece-em-arrays-multidimensionais?-2.5.3\"><span class=\"toc-item-num\">2.5.3&nbsp;&nbsp;</span>E o que acontece em arrays multidimensionais?</a></span></li></ul></li><li><span><a href=\"#Indexação,-fatiamento-e-iterações-em-arrays\" data-toc-modified-id=\"Indexação,-fatiamento-e-iterações-em-arrays-2.6\"><span class=\"toc-item-num\">2.6&nbsp;&nbsp;</span>Indexação, fatiamento e iterações em arrays</a></span><ul class=\"toc-item\"><li><span><a href=\"#Indexação\" data-toc-modified-id=\"Indexação-2.6.1\"><span class=\"toc-item-num\">2.6.1&nbsp;&nbsp;</span>Indexação</a></span></li><li><span><a href=\"#Fatiamento\" data-toc-modified-id=\"Fatiamento-2.6.2\"><span class=\"toc-item-num\">2.6.2&nbsp;&nbsp;</span>Fatiamento</a></span><ul class=\"toc-item\"><li><span><a href=\"#Array-unidimensional\" data-toc-modified-id=\"Array-unidimensional-2.6.2.1\"><span class=\"toc-item-num\">2.6.2.1&nbsp;&nbsp;</span>Array unidimensional</a></span></li><li><span><a href=\"#Array-multidimensional\" data-toc-modified-id=\"Array-multidimensional-2.6.2.2\"><span class=\"toc-item-num\">2.6.2.2&nbsp;&nbsp;</span>Array multidimensional</a></span></li></ul></li><li><span><a href=\"#Iterações\" data-toc-modified-id=\"Iterações-2.6.3\"><span class=\"toc-item-num\">2.6.3&nbsp;&nbsp;</span>Iterações</a></span></li></ul></li><li><span><a href=\"#Manipulação-de-shapes\" data-toc-modified-id=\"Manipulação-de-shapes-2.7\"><span class=\"toc-item-num\">2.7&nbsp;&nbsp;</span>Manipulação de shapes</a></span></li><li><span><a href=\"#Empilhamento-de-arrays\" data-toc-modified-id=\"Empilhamento-de-arrays-2.8\"><span class=\"toc-item-num\">2.8&nbsp;&nbsp;</span>Empilhamento de arrays</a></span></li><li><span><a href=\"#Cópias-e-visões-de-arrays\" data-toc-modified-id=\"Cópias-e-visões-de-arrays-2.9\"><span class=\"toc-item-num\">2.9&nbsp;&nbsp;</span>Cópias e visões de arrays</a></span><ul class=\"toc-item\"><li><span><a href=\"#Sem-cópias\" data-toc-modified-id=\"Sem-cópias-2.9.1\"><span class=\"toc-item-num\">2.9.1&nbsp;&nbsp;</span>Sem cópias</a></span></li><li><span><a href=\"#Visão-ou-cópia-raza-(shallow-copy)\" data-toc-modified-id=\"Visão-ou-cópia-raza-(shallow-copy)-2.9.2\"><span class=\"toc-item-num\">2.9.2&nbsp;&nbsp;</span>Visão ou cópia raza (shallow copy)</a></span></li><li><span><a href=\"#Cópia-profunda-(deep-copy)\" data-toc-modified-id=\"Cópia-profunda-(deep-copy)-2.9.3\"><span class=\"toc-item-num\">2.9.3&nbsp;&nbsp;</span>Cópia profunda (deep copy)</a></span></li></ul></li></ul></li><li><span><a href=\"#Aplicações-básicas-em-Álgebra-Linear-computacional\" data-toc-modified-id=\"Aplicações-básicas-em-Álgebra-Linear-computacional-3\"><span class=\"toc-item-num\">3&nbsp;&nbsp;</span>Aplicações básicas em Álgebra Linear computacional</a></span><ul class=\"toc-item\"><li><span><a href=\"#Operações-básicas\" data-toc-modified-id=\"Operações-básicas-3.1\"><span class=\"toc-item-num\">3.1&nbsp;&nbsp;</span>Operações básicas</a></span><ul class=\"toc-item\"><li><span><a href=\"#Transposta:-$A^T$\" data-toc-modified-id=\"Transposta:-$A^T$-3.1.1\"><span class=\"toc-item-num\">3.1.1&nbsp;&nbsp;</span>Transposta: $A^T$</a></span></li><li><span><a href=\"#Produto-interno\" data-toc-modified-id=\"Produto-interno-3.1.2\"><span class=\"toc-item-num\">3.1.2&nbsp;&nbsp;</span>Produto interno</a></span></li><li><span><a href=\"#Produto-diádico\" data-toc-modified-id=\"Produto-diádico-3.1.3\"><span class=\"toc-item-num\">3.1.3&nbsp;&nbsp;</span>Produto diádico</a></span></li><li><span><a href=\"#Produto-cruzado\" data-toc-modified-id=\"Produto-cruzado-3.1.4\"><span class=\"toc-item-num\">3.1.4&nbsp;&nbsp;</span>Produto cruzado</a></span></li><li><span><a href=\"#Produto-de-contração-tensorial\" data-toc-modified-id=\"Produto-de-contração-tensorial-3.1.5\"><span class=\"toc-item-num\">3.1.5&nbsp;&nbsp;</span>Produto de contração tensorial</a></span></li></ul></li><li><span><a href=\"#Característica-de-Matrizes-e-condicionamento\" data-toc-modified-id=\"Característica-de-Matrizes-e-condicionamento-3.2\"><span class=\"toc-item-num\">3.2&nbsp;&nbsp;</span>Característica de Matrizes e condicionamento</a></span><ul class=\"toc-item\"><li><span><a href=\"#Traço\" data-toc-modified-id=\"Traço-3.2.1\"><span class=\"toc-item-num\">3.2.1&nbsp;&nbsp;</span>Traço</a></span></li><li><span><a href=\"#Determinante\" data-toc-modified-id=\"Determinante-3.2.2\"><span class=\"toc-item-num\">3.2.2&nbsp;&nbsp;</span>Determinante</a></span></li><li><span><a href=\"#Número-de-condicionamento\" data-toc-modified-id=\"Número-de-condicionamento-3.2.3\"><span class=\"toc-item-num\">3.2.3&nbsp;&nbsp;</span>Número de condicionamento</a></span></li><li><span><a href=\"#Posto-de-uma-matriz\" data-toc-modified-id=\"Posto-de-uma-matriz-3.2.4\"><span class=\"toc-item-num\">3.2.4&nbsp;&nbsp;</span>Posto de uma matriz</a></span></li><li><span><a href=\"#Norma\" data-toc-modified-id=\"Norma-3.2.5\"><span class=\"toc-item-num\">3.2.5&nbsp;&nbsp;</span>Norma</a></span></li></ul></li><li><span><a href=\"#Autovalores-e-autovetores\" data-toc-modified-id=\"Autovalores-e-autovetores-3.3\"><span class=\"toc-item-num\">3.3&nbsp;&nbsp;</span>Autovalores e autovetores</a></span></li><li><span><a href=\"#Solução-de-sistemas-lineares\" data-toc-modified-id=\"Solução-de-sistemas-lineares-3.4\"><span class=\"toc-item-num\">3.4&nbsp;&nbsp;</span>Solução de sistemas lineares</a></span><ul class=\"toc-item\"><li><span><a href=\"#Inversa-de-uma-matriz\" data-toc-modified-id=\"Inversa-de-uma-matriz-3.4.1\"><span class=\"toc-item-num\">3.4.1&nbsp;&nbsp;</span>Inversa de uma matriz</a></span></li><li><span><a href=\"#Solução-de-sistemas-lineares\" data-toc-modified-id=\"Solução-de-sistemas-lineares-3.4.2\"><span class=\"toc-item-num\">3.4.2&nbsp;&nbsp;</span>Solução de sistemas lineares</a></span></li></ul></li></ul></li><li><span><a href=\"#Aplicações-básicas-em-Estatística\" data-toc-modified-id=\"Aplicações-básicas-em-Estatística-4\"><span class=\"toc-item-num\">4&nbsp;&nbsp;</span>Aplicações básicas em Estatística</a></span><ul class=\"toc-item\"><li><span><a href=\"#Média\" data-toc-modified-id=\"Média-4.1\"><span class=\"toc-item-num\">4.1&nbsp;&nbsp;</span>Média</a></span></li><li><span><a href=\"#Desvio-padrão\" data-toc-modified-id=\"Desvio-padrão-4.2\"><span class=\"toc-item-num\">4.2&nbsp;&nbsp;</span>Desvio-padrão</a></span></li><li><span><a href=\"#Variância\" data-toc-modified-id=\"Variância-4.3\"><span class=\"toc-item-num\">4.3&nbsp;&nbsp;</span>Variância</a></span></li></ul></li><li><span><a href=\"#Escrita-e-Leitura\" data-toc-modified-id=\"Escrita-e-Leitura-5\"><span class=\"toc-item-num\">5&nbsp;&nbsp;</span>Escrita e Leitura</a></span><ul class=\"toc-item\"><li><span><a href=\"#Escrita\" data-toc-modified-id=\"Escrita-5.1\"><span class=\"toc-item-num\">5.1&nbsp;&nbsp;</span>Escrita</a></span><ul class=\"toc-item\"><li><span><a href=\"#Escrita-de-um-único-vetor\" data-toc-modified-id=\"Escrita-de-um-único-vetor-5.1.1\"><span class=\"toc-item-num\">5.1.1&nbsp;&nbsp;</span>Escrita de um único vetor</a></span></li><li><span><a href=\"#Escrita-de-mais-de-um-vetor\" data-toc-modified-id=\"Escrita-de-mais-de-um-vetor-5.1.2\"><span class=\"toc-item-num\">5.1.2&nbsp;&nbsp;</span>Escrita de mais de um vetor</a></span></li><li><span><a href=\"#Escrita-de-uma-matriz\" data-toc-modified-id=\"Escrita-de-uma-matriz-5.1.3\"><span class=\"toc-item-num\">5.1.3&nbsp;&nbsp;</span>Escrita de uma matriz</a></span></li></ul></li><li><span><a href=\"#Leitura\" data-toc-modified-id=\"Leitura-5.2\"><span class=\"toc-item-num\">5.2&nbsp;&nbsp;</span>Leitura</a></span><ul class=\"toc-item\"><li><span><a href=\"#Leitura-simples-de-um-vetor-em-arquivo\" data-toc-modified-id=\"Leitura-simples-de-um-vetor-em-arquivo-5.2.1\"><span class=\"toc-item-num\">5.2.1&nbsp;&nbsp;</span>Leitura simples de um vetor em arquivo</a></span></li><li><span><a href=\"#Leitura-de-2-ou-mais-vetores-por-linhas\" data-toc-modified-id=\"Leitura-de-2-ou-mais-vetores-por-linhas-5.2.2\"><span class=\"toc-item-num\">5.2.2&nbsp;&nbsp;</span>Leitura de 2 ou mais vetores por linhas</a></span></li><li><span><a href=\"#Leitura-de-2-ou-mais-vetores-por-coluna\" data-toc-modified-id=\"Leitura-de-2-ou-mais-vetores-por-coluna-5.2.3\"><span class=\"toc-item-num\">5.2.3&nbsp;&nbsp;</span>Leitura de 2 ou mais vetores por coluna</a></span></li><li><span><a href=\"#Leitura-de-partes-de-uma-matriz-em-arrays\" data-toc-modified-id=\"Leitura-de-partes-de-uma-matriz-em-arrays-5.2.4\"><span class=\"toc-item-num\">5.2.4&nbsp;&nbsp;</span>Leitura de partes de uma matriz em arrays</a></span></li><li><span><a href=\"#Leitura-de-uma-matriz\" data-toc-modified-id=\"Leitura-de-uma-matriz-5.2.5\"><span class=\"toc-item-num\">5.2.5&nbsp;&nbsp;</span>Leitura de uma matriz</a></span></li></ul></li></ul></li><li><span><a href=\"#Próximos-passos\" data-toc-modified-id=\"Próximos-passos-6\"><span class=\"toc-item-num\">6&nbsp;&nbsp;</span>Próximos passos</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pré-requisitos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos explorar nossos estudos desse ponto em diante de duas formas:\n",
    "\n",
    "* Localmente com Jupyter Notebooks;\n",
    "* Remotamente com o [Google Colab](https://colab.research.google.com).\n",
    "\n",
    "Este último já vem previamente configurado com todas as libs que utilizaremos na parte numérica do curso. Para a primeira opção, para que tudo corra bem, precisamos garantir que todo mundo está utilizando a mesma versão tanto do Python quanto em suas libs. Para isso, vamos utilizar o [conda](https://conda.io/en/latest/), um gerenciador open source de pacotes e ambientes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Instalação do conda (Miniconda)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso sua máquina não possua o conda instalado, você pode baixar o instalador condizente com seu computador e sistema operacional [neste link](https://conda.io/en/latest/miniconda.html), basta seguir as instruções lá providenciadas. Com isso, você instalará o Miniconda - a versão com \"o mínimo necessário\" do conda - em seu computador, que é o que iremos precisar aqui."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Utilizando e instalando ambientes (envs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Após instalado o `conda` e reiniciado seu terminal, você deve ser capaz de checar os ambientes (environments, que chamaremos apenas de envs) instalados (execute o comando abaixo sem `!` no seu terminal):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "# conda environments:\r\n",
      "#\r\n",
      "base                     /home/volps/miniconda3\r\n",
      "brumadinho               /home/volps/miniconda3/envs/brumadinho\r\n",
      "daml                     /home/volps/miniconda3/envs/daml\r\n",
      "fenics16-1               /home/volps/miniconda3/envs/fenics16-1\r\n",
      "fenics16-2               /home/volps/miniconda3/envs/fenics16-2\r\n",
      "fenics17-1               /home/volps/miniconda3/envs/fenics17-1\r\n",
      "fenics17-2               /home/volps/miniconda3/envs/fenics17-2\r\n",
      "fenics18-1               /home/volps/miniconda3/envs/fenics18-1\r\n",
      "sci                      /home/volps/miniconda3/envs/sci\r\n",
      "sci_env               *  /home/volps/miniconda3/envs/sci_env\r\n",
      "\r\n"
     ]
    }
   ],
   "source": [
    "!conda env list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este comando lista os envs instalados. Note que já temos um env que você provavelmente ainda não tem (a menos que vc esteja executando este notebook no Colab). Vamos resolver isso?\n",
    "\n",
    "Para tanto, siga a sequência de passos abaixo:\n",
    "\n",
    "1. Clone o repositório remoto do curso para sua máquina com o comando `git clone https://github.com/pedrosiracusa/curso_python_eamc.git` e entre no diretório com `cd curso_python_eamc`\n",
    "\n",
    "2. Adicione o canal (`conda-forge`) que utilizaremos para baixar os pacotes corretos no conda: `conda config --add channels conda-forge`\n",
    "\n",
    "3. Crie o mesmo pacote que temos - o `sci_env` - por meio do arquivo de dependências `sci_env.yml` com o seguinte comando: `conda env create -f sci_env.yml`\n",
    "\n",
    "4. Aguarde a instala...zzzzZZZZZZZZZZZZZZZZzzZZZzz\n",
    "\n",
    "5. Após a instalação, reinicie seu terminal e acesse o ambiente com o comando `source activate sci_env` (Linux) ou `conda activate sci_env` (Windows).\n",
    "\n",
    "Pronto, com isso temos exatamente o mesmo ambiente, com as mesmas bibliotecas!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## NumPy\n",
    "--------------------------------------"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### O que é?\n",
    "\n",
    "É um pacote fundamental para aplicações de computação científica em Python. Com ele, o desenvolvedor é capaz de:\n",
    "\n",
    "* Montar objetos matriciais N-dimensionais e objetos derivados desses;\n",
    "* Realizar operações eficientes de Álgebra Linear computacional;\n",
    "* Operações básicas de Estatística;\n",
    "* Utilizar geração de números pseudo-aleatórios;\n",
    "* Operações vetorizadas;\n",
    "* Integrar com códigos em C/C++ e Fortran;\n",
    "\n",
    "E muito mais!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Conceitos básicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Importando o pacote"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tipo básico: `numpy.ndarray`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O tipo básico da `numpy` é o `numpy.ndarray`, o quão chamaremos aqui frequentemente de \"array\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Inicializando"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Um simples vetor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 2., 3.])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1 = np.array([1., 2., 3.])\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 2., 3.],\n",
       "       [4., 5., 6.],\n",
       "       [7., 8., 9.]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1 = np.array(\n",
    "    [[1., 2., 3.],\n",
    "     [4., 5., 6.],\n",
    "     [7., 8., 9.]]\n",
    ")\n",
    "\n",
    "matrix1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a matriz nada mais é que um array de arrays.\n",
    "\n",
    "Ao longo do curso, veremos outras formas de inicializar arrays."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Atenção!!!**\n",
    "\n",
    "A entrada para a criação de arrays deve ser listas ou tuplas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_tuple = np.array((1, 2, 3))\n",
    "\n",
    "array_tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix_mixed = np.array(\n",
    "    [(1, 2, 3),\n",
    "    [4, 5, 6]]\n",
    ")\n",
    "\n",
    "matrix_mixed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Inicializando arrays preenchidos com zeros ou um"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em algumas situações, já são conhecidas as demandas e estruturas dos arrays que vão ser utilizados. Neste caso, o numpy oferece funções para criar arrays preenchidos com zeros ou um."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_zeros = np.zeros(3)\n",
    "array_zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.],\n",
       "       [0., 0., 0., 0.]])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape = (4, 4)\n",
    "matrix_zeros = np.zeros(shape)\n",
    "matrix_zeros"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analogamente, podemos fazer com valor unitário."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_ones = np.ones(3)\n",
    "array_ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.],\n",
       "       [1., 1., 1., 1.]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape = (4, 4)\n",
    "matrix_ones = np.ones(shape)\n",
    "matrix_ones"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Atributos básicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Número de eixos (axes) do array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.ndim"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.ndim"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que uma matriz, nesse caso, é considerado um objeto bidimensional, já que são arrays dentro de um array."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Forma de um array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`ndarray.shape` fornece as dimensões de cada eixo. No caso de uma matriz $A \\in \\mathbb{R}^{m\\,\\times\\,n}$, como temos em `matrix1`, `ndarray.shape` retorna justamente $(m, n)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Tamanho de um array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Retorna o número de entrada de valores no objeto `ndarray`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Tipo dos elementos em um array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou seja, todas as entradas foram compostas por números em representação de ponto flutuante de dupla precisão. Caso seja necessário utilizar outro tipo de representação, podemos especificar isso na hora de declaramos o array por meio do argumento `dtype`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrix1_32 = np.array(\n",
    "    [[1., 2., 3.],\n",
    "     [4., 5., 6.],\n",
    "     [7., 8., 9.]],\n",
    "    dtype=np.float32\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float32')"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1_32.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou mesmo podemos criar arrays de números complexos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.+3.j, 1.+0.j]])"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array_complex = np.array([[2. + 3.j, 1.]], dtype=np.complex)\n",
    "\n",
    "array_complex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2.+1.j, 1.+0.j],\n",
       "       [0.+0.j, 0.+1.j]])"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix_complex = np.array(\n",
    "    [[2. + 1.j, 1.],\n",
    "     [0., 1.j]], \n",
    "    dtype=np.complex\n",
    ")\n",
    "\n",
    "matrix_complex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Tamanhos dos itens em bytes de um array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.itemsize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1_32.itemsize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que um array de `float64` tem $\\dfrac{64}{8} = 8$ bytes, enquanto um `float32` tem $\\dfrac{32}{8} = 4$ bytes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Endereço dos dados em memória:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<memory at 0x7f6fa4667288>"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<memory at 0x7f6fb8067630>"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<memory at 0x7f6fb8067b40>"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1_32.data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em Python, geralmente não utilizamos esse tipo de acesso ou informação. Utilizamos apenas a **_parte boa_** do C."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operações e utilitários básicos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Criação de arrays a partir de intervalos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6, 8])"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence_1 = np.arange(start=2, stop=10, step=2)\n",
    "\n",
    "sequence_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 4., 6., 8.])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence_2 = np.linspace(start=2, stop=8, num=4)\n",
    "\n",
    "sequence_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que embora ambos criem arrays igualmente espaçados, exite uma diferença na forma de uso. O `np.arange` te possibilita dizer o início e o fim, sendo que o fim não está incluso (assim como ocorre com os _slicing_ de listas). Além disso, o `np.arange` controla o incremento que será utilizado até alcançar o fim da sequência.\n",
    "\n",
    "Em contrapartida, o `np.linspace` controla precisamente o início e o fim (que estará incluso). No entanto, ele tem como entrada no terceiro argumento (aqui explicitado) a quantidade de pontos que terá entre o início e o fim. O incremento será consequência disso."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para simplificar, geralmente ambos os métodos são usados com o nome dos argumentos implícitos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6, 8])"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence_1 = np.arange(2, 10, 2)\n",
    "\n",
    "sequence_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 4., 6., 8.])"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence_2 = np.linspace(2, 8, 4)\n",
    "\n",
    "sequence_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([  0.        ,   0.50251256,   1.00502513,   1.50753769,\n",
       "         2.01005025,   2.51256281,   3.01507538,   3.51758794,\n",
       "         4.0201005 ,   4.52261307,   5.02512563,   5.52763819,\n",
       "         6.03015075,   6.53266332,   7.03517588,   7.53768844,\n",
       "         8.04020101,   8.54271357,   9.04522613,   9.54773869,\n",
       "        10.05025126,  10.55276382,  11.05527638,  11.55778894,\n",
       "        12.06030151,  12.56281407,  13.06532663,  13.5678392 ,\n",
       "        14.07035176,  14.57286432,  15.07537688,  15.57788945,\n",
       "        16.08040201,  16.58291457,  17.08542714,  17.5879397 ,\n",
       "        18.09045226,  18.59296482,  19.09547739,  19.59798995,\n",
       "        20.10050251,  20.60301508,  21.10552764,  21.6080402 ,\n",
       "        22.11055276,  22.61306533,  23.11557789,  23.61809045,\n",
       "        24.12060302,  24.62311558,  25.12562814,  25.6281407 ,\n",
       "        26.13065327,  26.63316583,  27.13567839,  27.63819095,\n",
       "        28.14070352,  28.64321608,  29.14572864,  29.64824121,\n",
       "        30.15075377,  30.65326633,  31.15577889,  31.65829146,\n",
       "        32.16080402,  32.66331658,  33.16582915,  33.66834171,\n",
       "        34.17085427,  34.67336683,  35.1758794 ,  35.67839196,\n",
       "        36.18090452,  36.68341709,  37.18592965,  37.68844221,\n",
       "        38.19095477,  38.69346734,  39.1959799 ,  39.69849246,\n",
       "        40.20100503,  40.70351759,  41.20603015,  41.70854271,\n",
       "        42.21105528,  42.71356784,  43.2160804 ,  43.71859296,\n",
       "        44.22110553,  44.72361809,  45.22613065,  45.72864322,\n",
       "        46.23115578,  46.73366834,  47.2361809 ,  47.73869347,\n",
       "        48.24120603,  48.74371859,  49.24623116,  49.74874372,\n",
       "        50.25125628,  50.75376884,  51.25628141,  51.75879397,\n",
       "        52.26130653,  52.7638191 ,  53.26633166,  53.76884422,\n",
       "        54.27135678,  54.77386935,  55.27638191,  55.77889447,\n",
       "        56.28140704,  56.7839196 ,  57.28643216,  57.78894472,\n",
       "        58.29145729,  58.79396985,  59.29648241,  59.79899497,\n",
       "        60.30150754,  60.8040201 ,  61.30653266,  61.80904523,\n",
       "        62.31155779,  62.81407035,  63.31658291,  63.81909548,\n",
       "        64.32160804,  64.8241206 ,  65.32663317,  65.82914573,\n",
       "        66.33165829,  66.83417085,  67.33668342,  67.83919598,\n",
       "        68.34170854,  68.84422111,  69.34673367,  69.84924623,\n",
       "        70.35175879,  70.85427136,  71.35678392,  71.85929648,\n",
       "        72.36180905,  72.86432161,  73.36683417,  73.86934673,\n",
       "        74.3718593 ,  74.87437186,  75.37688442,  75.87939698,\n",
       "        76.38190955,  76.88442211,  77.38693467,  77.88944724,\n",
       "        78.3919598 ,  78.89447236,  79.39698492,  79.89949749,\n",
       "        80.40201005,  80.90452261,  81.40703518,  81.90954774,\n",
       "        82.4120603 ,  82.91457286,  83.41708543,  83.91959799,\n",
       "        84.42211055,  84.92462312,  85.42713568,  85.92964824,\n",
       "        86.4321608 ,  86.93467337,  87.43718593,  87.93969849,\n",
       "        88.44221106,  88.94472362,  89.44723618,  89.94974874,\n",
       "        90.45226131,  90.95477387,  91.45728643,  91.95979899,\n",
       "        92.46231156,  92.96482412,  93.46733668,  93.96984925,\n",
       "        94.47236181,  94.97487437,  95.47738693,  95.9798995 ,\n",
       "        96.48241206,  96.98492462,  97.48743719,  97.98994975,\n",
       "        98.49246231,  98.99497487,  99.49748744, 100.        ])"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sequence_3 = np.linspace(0, 100, 200)\n",
    "\n",
    "sequence_3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Operações aritméticas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Com o numpy, as operações aritméticas são realizadas elemento-por-elemento do array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.arange(5)\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "(note que se `np.arange` tiver apenas um argumento, ele gerará uma sequência igualmente espaçada até o número inteiro imediatamente antes ao argumento)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0, 10, 20, 30, 40])"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.arange(0, 50, 10)\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 11 22 33 44]\n",
      "[ 0  9 18 27 36]\n",
      "[ 0  1  4  9 16]\n",
      "[10. 10. 10. 10.]\n",
      "[  0  10  40  90 160]\n"
     ]
    }
   ],
   "source": [
    "soma = a + b\n",
    "subtracao = b - a\n",
    "potenciacao = a ** 2\n",
    "divisao = b[1:] / a[1:]\n",
    "produto = a * b\n",
    "\n",
    "print(soma)\n",
    "print(subtracao)\n",
    "print(potenciacao)\n",
    "print(divisao)\n",
    "print(produto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a operação de divisão de vetores não é matematicamente definida, mas aqui é possível pois se trata de operações elemento-por-elemento. Além disso, o produto entre vetores matematicamente definido como produto interno não ocorre por meio do operador `*` (iremos ver isso em breve). Podemos fazer com matrizes de maneira similar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 3.]\n",
      " [2. 4.]] \n",
      "\n",
      "[[10.  0.]\n",
      " [10. 20.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array(\n",
    "    [[1., 3.], \n",
    "     [2., 4.]]\n",
    ")\n",
    "B = np.array(\n",
    "    [[10., 0.], \n",
    "     [10., 20.]]\n",
    ")\n",
    "\n",
    "print(A, '\\n')\n",
    "print(B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[11.  3.]\n",
      " [12. 24.]] \n",
      "\n",
      "[[ 9. -3.]\n",
      " [ 8. 16.]] \n",
      "\n",
      "[[ 1.  9.]\n",
      " [ 4. 16.]] \n",
      "\n",
      "[[10.  0.]\n",
      " [ 5.  5.]] \n",
      "\n",
      "[[10.  0.]\n",
      " [20. 80.]]\n"
     ]
    }
   ],
   "source": [
    "soma = A + B\n",
    "subtracao = B - A\n",
    "potenciacao = A ** 2\n",
    "divisao = B / A\n",
    "produto = A * B\n",
    "\n",
    "print(soma, '\\n')\n",
    "print(subtracao, '\\n')\n",
    "print(potenciacao, '\\n')\n",
    "print(divisao, '\\n')\n",
    "print(produto)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Novamente, note que a operação de divisão em matrizes matematicamente não existe e o produto entre matrizes também não é o usual. As operações que ocorrem acima foram realizadas elemento-por-elemento. Caso desejemos realizar o produto de matrizes, o Python oferece um operador específico para isso:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[40., 60.],\n",
       "       [60., 80.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "produto_matrizes = A @ B\n",
    "\n",
    "produto_matrizes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[40., 60.],\n",
       "       [60., 80.]])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "produto_matrizes_alternativo = A.dot(B)\n",
    "\n",
    "produto_matrizes_alternativo"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sendo esse último uma notação mais verbosa do que está ocorrendo. Podemos, dessa forma, fazer a clássica operação entre matrizes e vetores do tipo $Ax$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2., 1.])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mat = np.array([[2., 1.], [1, 2.]])\n",
    "vec = np.array([1., 0.])\n",
    "prod_matvec = mat @ vec\n",
    "\n",
    "prod_matvec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Comentários sobre operações com tipos de dados distintos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Quando se opera objetos `ndarray` com tipos diferentes, o que será que acontece?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1], dtype=int32)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = np.ones(3, dtype=np.int32)\n",
    "\n",
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0. , 2.5, 5. ])"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.linspace(0, 5, 3)\n",
    "\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1. , 3.5, 6. ])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a + b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que ocorre uma coerção de tipo para o que apresentar maior grau de precisão (ou mais genérico)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Funções universais da NumPy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A NumPy fornece as principais funções matemáticas capazes de operar de forma vetorial. Em outras palavras, capaz de retornar arrays, ao contrário da biblioteca-padrão `math`. Vamos ver um exemplo simples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "\n",
    "def sin_function(x):\n",
    "    return math.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "only size-1 arrays can be converted to Python scalars",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-46-f2b7933f87d0>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mvec\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;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m2\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[0;32m----> 2\u001b[0;31m \u001b[0msin_vec\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msin_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvec\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0msin_vec\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-45-f0da795297e3>\u001b[0m in \u001b[0;36msin_function\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msin_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\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[0;32m----> 5\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mmath\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msin\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: only size-1 arrays can be converted to Python scalars"
     ]
    }
   ],
   "source": [
    "vec = np.array([1 / 3, 1 / 2])\n",
    "sin_vec = sin_function(vec)\n",
    "\n",
    "sin_vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pela numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sin_function_np(x):\n",
    "    return np.sin(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.3271947 , 0.47942554])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sin_vec = sin_function_np(vec)\n",
    "\n",
    "sin_vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basicamente, as funções fornecidas são as mesmas que as da lib `math`, porém com a capacidade exibida acima. Lembrando que essas funções também são executadas elemento-por-elemento. A lista completa de funções disponíveis pode ser acessada [aqui](https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.math.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Alguns métodos de `numpy.ndarray` úteis"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "No dia-a-dia científico, muitas vezes necessitamos de algumas operações com certa frequência, como somas em vetores, valores máximos ou mínimos e etc. Os objetos `ndarray` são munidos de métodos que executam esses cálculos. Vejamos alguns deles a seguir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Valores máximos e mínimos em um array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos antes gerar um vetor de valores aleatórios com o pacote `random` do numpy:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.34336861, 0.27182526, 0.13845444, 0.90895815, 0.02422253,\n",
       "       0.42396994, 0.74019314, 0.9223146 , 0.50825702, 0.16044042])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from numpy import random as rnd\n",
    "\n",
    "array1 = rnd.random(10)\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Criamos um vetor com 10 entradas aleatórias entre 0 e 1. Agora vamos retirar algumas informações sobre ele."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Valor máximo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9223146022241675"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Índice da entrada de valor máximo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "imax = array1.argmax()\n",
    "imax"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9223146022241675"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1[imax]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Valor mínimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.024222528975309188"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Índice da entrada de valor mínimo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.argmin()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Somatório e produtórios dos valores em um array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Soma dos valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.442004105570682"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Soma cumulativa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.34336861, 0.61519386, 0.7536483 , 1.66260645, 1.68682898,\n",
       "       2.11079892, 2.85099206, 3.77330666, 4.28156368, 4.44200411])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.cumsum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.allclose(array1.sum(), array1.cumsum()[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Produto dos valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6.715479688671335e-06"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.prod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Produto cumulativo dos valores"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3.43368606e-01, 9.33362595e-02, 1.29228197e-02, 1.17463022e-02,\n",
       "       2.84525147e-04, 1.20630108e-04, 8.92895791e-05, 8.23530826e-05,\n",
       "       4.18565325e-05, 6.71547969e-06])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.cumprod()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é constatado que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1.prod() == array1.cumprod()[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### E o que acontece em arrays multidimensionais?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste caso, o formato não é levado em conta. O método é aplicado ao longo do array como se os valores de entradas fossem uma lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.52757469, 0.44499104, 0.24150775],\n",
       "       [0.17061932, 0.23133227, 0.48625264],\n",
       "       [0.79868698, 0.93480275, 0.93662729]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape = (3, 3)\n",
    "vec1 = rnd.random(shape)\n",
    "\n",
    "vec1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.1706193224360818"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec1.min()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Porém, podemos especificar em qual `axis` os métodos serão aplicados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.24150775, 0.17061932, 0.79868698])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec1.min(axis=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A operação acima retornou o mínimo de cada linha. Analogamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.17061932, 0.23133227, 0.24150775])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vec1.min(axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "retornou o mínimo em cada coluna. O procedimento pode ser aplicado da mesma maneira para as funções expostas anteriormente."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexação, fatiamento e iterações em arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Indexação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 5.        ,  6.66666667,  8.33333333, 10.        , 11.66666667,\n",
       "       13.33333333, 15.        , 16.66666667, 18.33333333, 20.        ])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1 = np.linspace(5, 20, 10)\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Semelhantemente às listas, os índices começam a contar do 0. Portanto, a entrada na posição 3 é acessado como"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.333333333333334"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Fatiamento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Array unidimensional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em algumas situações, se deseja acessar ou operar em apenas uma parte de um array. No array unidimensional, basta fazer `array[n:m]`. Isso retornará as entradas do índice `n` até o `m-1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.        , 6.66666667, 8.33333333])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1[0:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste caso, como o índice inicial é `0`, podemos omitir e simplesmente fazer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([5.        , 6.66666667, 8.33333333])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1[:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma semelhante, se fizermos `array[n:]` a fatia ocorrerá do índice `n` até o fim do array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([16.66666667, 18.33333333, 20.        ])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1[7:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Outro exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 8.33333333, 10.        , 11.66666667, 13.33333333, 15.        ,\n",
       "       16.66666667])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sliced_array = array1[2:8]\n",
    "sliced_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos fazer operações em apenas trechos dos arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15.        , 16.66666667, 18.33333333])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1[:3] + 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ou operar partes de arrays com outras partes de outras arrays **(sem fazer laços!)**, desde que sejam compatíveis em tamanho e dimensões:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 7.77777778, 10.        , 12.22222222, 14.44444444, 16.66666667])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 = np.linspace(0, 5, 10)\n",
    "array3 = array1[:5] + array2[5:]\n",
    "\n",
    "array3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse tipo de operação entre arrays, sem laços, é conhecida como uma das coisas mais poderosas da NumPy, e é comumente chamado de vetorização. Vejamos que alguns exemplos de performance:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1, array2 = rnd.random(1000), rnd.random(1000)\n",
    "n = 800"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "661 µs ± 11.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "array3 = np.zeros(n)\n",
    "for i in range(n):\n",
    "    array3[i] = array1[i] + array2[i]\n",
    "    \n",
    "array3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.95 µs ± 393 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "array3 = array1[:n] + array2[:n]\n",
    "\n",
    "array3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então podemos verificar que há um ganho de performance/complexidade temporal na ordem de 300 com a operação vetorizada."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Array multidimensional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste caso, o fatiamento é aplicado em cada eixo (`axis`) separadamente."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 0 4]\n",
      " [3 1 4 4]\n",
      " [1 1 1 0]\n",
      " [2 1 2 2]]\n"
     ]
    }
   ],
   "source": [
    "shape = (4, 4)\n",
    "matrix1 = rnd.randint(5, size=shape)\n",
    "\n",
    "print(matrix1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Todas as linhas (`:`) da coluna 2:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 1, 1])"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1[:, 1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Todas as colunas da linha 4:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 1, 2, 2])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1[3, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Uma matriz formada das linhas 1 até 3 e com as colunas de 2 e 3 `matrix1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[2, 0],\n",
       "       [1, 4],\n",
       "       [1, 1]])"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix2 = matrix1[:3, 1:3]\n",
    "\n",
    "matrix2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos fazer também um comparativo de performance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "shape = (200, 200)\n",
    "matrix1 = rnd.randint(5, size=shape)\n",
    "matrix2 = rnd.randint(5, size=shape)\n",
    "matrix3, matrix3_loop = np.zeros(shape), np.zeros(shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23.2 ms ± 477 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "for j in range(matrix1.shape[0]):\n",
    "    for i in range(matrix1.shape[1]):\n",
    "        matrix3_loop[i, j] = matrix1[i, j] + matrix2[i, j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "43.5 µs ± 586 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "matrix3[:, :] = matrix1[:, :] + matrix2[:, :]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apenas fazendo um simples teste de sanidade:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array_equal(matrix3, matrix3_loop)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Disso, vemos que as operações foram equivalentes, porém a forma vetorizada teve um ganho em performance/complexidade temporal praticamente de $\\mathcal{O}(10^3)$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Iterações"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "De forma análoga às listas em Python, podemos iterar sobre objetos `numpy.ndarray`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3, 0],\n",
       "       [9, 6, 3],\n",
       "       [4, 9, 9]])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1 = rnd.randint(10, size=(3, 3))\n",
    "matrix1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3 0]\n",
      "[9 6 3]\n",
      "[4 9 9]\n"
     ]
    }
   ],
   "source": [
    "for row in matrix1:\n",
    "    print(row)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também é válido para percorrer elementos em vetores (arrays unidimensionais):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 3, 0, 4])"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1 = rnd.randint(5, size=5)\n",
    "array1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "2\n",
      "3\n",
      "0\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for element in array1:\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manipulação de shapes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em situações práticas, pode ser que seja necessário um rearranjo da configuração de um array. Aqui veremos brevemente como podemos mudar os shapes dos arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 8, 0],\n",
       "       [1, 2, 7, 7],\n",
       "       [7, 7, 5, 4]])"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "shape = (3, 4)\n",
    "matrix1 = rnd.randint(10, size=shape)\n",
    "\n",
    "matrix1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 4)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como já vimos, o atributo `shape` nos informa quantos elementos há em cada eixo do array multidimensional. Inicialmente, vamos transformar a `matrix1` em um array unidimensional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([3, 7, 8, 0, 1, 2, 7, 7, 7, 7, 5, 4])"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1.ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos também rearranjar o conteúdo de um array para um outro shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 8, 0, 1, 2],\n",
       "       [7, 7, 7, 7, 5, 4]])"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_shape = (2, 6)\n",
    "matrix1.reshape(new_shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que é necessário que `shape[0] * shape[1] = new_shape[0] * new_shape[1]`. Mais precisamente, o tamanho do array rearranjado deve ser igual ao do array original. Veja o erro abaixo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "cannot reshape array of size 12 into shape (3,3)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-92-e395430efd40>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mnew_shape\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmatrix1\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnew_shape\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: cannot reshape array of size 12 into shape (3,3)"
     ]
    }
   ],
   "source": [
    "new_shape = (3, 3)\n",
    "matrix1.reshape(new_shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante observar que o `reshape` não altera o array original, apenas devolve um array rearranjado em relação ao original:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 8, 0],\n",
       "       [1, 2, 7, 7],\n",
       "       [7, 7, 5, 4]])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matrix1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Portanto, `matrix1` se mantém inalterada. Isso não ocorre quando se utiliza o `resize`, que modifica também o array original:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[3, 7, 8, 0, 1, 2],\n",
       "       [7, 7, 7, 7, 5, 4]])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_shape = (2, 6)\n",
    "matrix1.resize(new_shape)\n",
    "\n",
    "matrix1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Empilhamento de arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Digamos que precisamos unir os dados presentes em dois arrays diferentes. Aqui veremos sucintamente algumas maneiras de fazer isso."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 3]\n",
      " [2 1]] \n",
      "\n",
      "[[1 3]\n",
      " [2 3]]\n"
     ]
    }
   ],
   "source": [
    "shape = (2, 2)\n",
    "matrix1, matrix2 = rnd.randint(5, size=shape), rnd.randint(4, size=shape)\n",
    "\n",
    "print(matrix1, '\\n')\n",
    "print(matrix2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Empilhamento horizontal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Os arrays são concatenados horizontalmente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3, 1, 3],\n",
       "       [2, 1, 2, 3]])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.hstack([matrix1, matrix2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Empilhamento vertical"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analogamente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 3],\n",
       "       [2, 1],\n",
       "       [1, 3],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.vstack([matrix1, matrix2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Empilhamento de um vetor como coluna em uma matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "all the input arrays must have same number of dimensions",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-98-9bfd43ac53dc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0marray1\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;36m10.\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10.\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[0mhstack\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mmatrix1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0marray1\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;32m~/miniconda3/envs/sci_env/lib/python3.7/site-packages/numpy/core/shape_base.py\u001b[0m in \u001b[0;36mhstack\u001b[0;34m(tup)\u001b[0m\n\u001b[1;32m    338\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0m_nx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    339\u001b[0m     \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 340\u001b[0;31m         \u001b[0;32mreturn\u001b[0m \u001b[0m_nx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0marrs\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[0m\n\u001b[0m\u001b[1;32m    341\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    342\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: all the input arrays must have same number of dimensions"
     ]
    }
   ],
   "source": [
    "array1 = np.array([10., 10.])\n",
    "\n",
    "np.hstack([matrix1, array1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe que isso não é possível com o `hstack`. Porém, temos o `column_stack` para nos salvar!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  3., 10.],\n",
       "       [ 2.,  1., 10.]])"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.column_stack([matrix1, array1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos utilizar o `column_stack` para montar um array multidimensional a partir de arrays que irão compor as colunas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10., 15.],\n",
       "       [10., 30.]])"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 = np.array([15, 30])\n",
    "\n",
    "np.column_stack([array1, array2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Analogamente, podemos concatenar como linhas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10., 10.],\n",
       "       [15., 30.]])"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.row_stack([array1, array2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em tempo, podemos adicionar dois arrays com a função `append`, que difere um pouco do seu primo nos objetos `list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10., 10., 15., 30.])"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.append(array1, array2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso também pode ser usado no numpy para criar arrays \"dinamicamente\" (que não existe no numpy, exatamente):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 1., 2., 3., 4., 5., 6., 7., 8., 9.])"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "an_array = np.array([])  # cria um array vazio\n",
    "for i in range(10):\n",
    "    an_array = np.append(an_array, i)\n",
    "    \n",
    "an_array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A grosso modo, a função `append` possui a seguinte sintaxe: `np.append(array, value)`, onde `array` será adicionado por `value`, que pode ser também um outro `ndarray` ou tipos compatíveis, como `list` ou `tuple`. O `append` não modifica o `array`, retorna um novo `ndarray` com operado como requerido na chamada da função.\n",
    "\n",
    "**Observação:** Criar arrays com `append` pode ser custoso! Afinal, usa laços em Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Cópias e visões de arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Durante criação e manipulações de arrays, às vezes cópias são realizadas ou às vezes temos apenas visões dos arrays. Com numpy, temos alguns tipos de cópias e isso pode ser crucial quando desejamos manipular dados apropriadamente ou mantê-los intactos. Basicamente, temos apenas três casos e os veremos a seguir."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sem cópias"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Em geral, declarações não fazem cópias dos arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 2, 4, 6, 8])"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1 = np.arange(0, 10, 2)\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 = array1\n",
    "\n",
    "array1 is array2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então os arrays são iguais. Em Python, isso quer dizer que um mesmo objeto possui dois nomes (ou mais). O que acontece se um dos arrays for modificado?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0,  2,  4,  6, 10])"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2[-1] = 10\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É importante ter **muita atenção** nisso, pois é uma fonte de bugs frequente. Funções em Python também modificam o valor dos argumentos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f_bug(x):\n",
    "    x[0] = 20.0\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[20  2  4  6 10]\n"
     ]
    }
   ],
   "source": [
    "f_bug(array1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2,  4,  6, 10])"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Isso é conhecido como **passagem por referência** de um argumento de uma função."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Visão ou cópia raza (shallow copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Neste caso, diferentes objetos compartilham os mesmos dados. O método `view` cria um novo array com dados iguais aos de outro array."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2,  4,  6, 10])"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 = array1.view()\n",
    "\n",
    "array2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 is array1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2.base is array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O que acontece com o `array1` se modificarmos o `array2`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2,  4,  6, 10])"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array2 = array2 + 5\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aparentemente tudo OK! Esse tipo de cópia ocorre nos fatiamentos, onde são geradas as \"visões\" dos dados para um novo array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6])"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array3 = array1[1:4]\n",
    "\n",
    "array3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2, 40,  6, 10])"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array3[1] = 40\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Então também devemos tomar cuidado com isso!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Cópia profunda (deep copy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "É uma perfeita cópia, totalmente independente dos dados originais (e segura!). É feita por meio do método `copy()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [],
   "source": [
    "array3 = array1.copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array3 is array1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array3.base is array1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([20,  2, 40,  6, 10])"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "array3[:3] = 0.0\n",
    "\n",
    "array1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E assim estamos totalmente a salvo!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aplicações básicas em Álgebra Linear computacional"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nesta seção, iremos ver algumas das funcionalidades voltadas para Álgebra Linear computacional em alguns problemas frequentes. Para consultas e detalhes das funcionalidades disponibilizadas abaixo, a [documentação oficial](https://docs.scipy.org/doc/numpy-1.15.1/reference/routines.linalg.html).\n",
    "\n",
    "A NumPy fornece apenas algumas funcionalidades básicas. Métodos mais complexos e eficientes podem ser utilizados no SciPy, como veremos mais na frente do curso. Na NumPy, as funções de Álgebra Linear estão no sub-pacote `numpy.linalg`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy.linalg as la"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operações básicas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vetores e matrizes para testes: $u, v \\in \\mathbb{R}^n$ e $A, B \\in \\mathbb{R}^{n\\,\\times\\,n}$, $n = 3$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "u:\n",
      " [0.57012495 0.27262238 0.71554926] \n",
      "\n",
      "v:\n",
      " [0.14246231 0.76020427 0.00672093] \n",
      "\n",
      "A:\n",
      " [[0.36349565 0.62509516 0.40577012]\n",
      " [0.71787282 0.91853055 0.71335495]\n",
      " [0.55643619 0.10764589 0.7500328 ]] \n",
      "\n",
      "B:\n",
      " [[0.52474217 0.3235028  0.31363832]\n",
      " [0.24603614 0.40909994 0.14241992]\n",
      " [0.22472984 0.92455571 0.45881707]]\n"
     ]
    }
   ],
   "source": [
    "n = 3\n",
    "shape = (n, n)\n",
    "u, v = rnd.random(n), rnd.random(n)\n",
    "A, B = rnd.random(size=shape), rnd.random(size=shape)\n",
    "\n",
    "print('u:\\n', u, '\\n')\n",
    "print('v:\\n', v, '\\n')\n",
    "print('A:\\n', A, '\\n')\n",
    "print('B:\\n', B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Transposta: $A^T$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.36349565, 0.71787282, 0.55643619],\n",
       "       [0.62509516, 0.91853055, 0.10764589],\n",
       "       [0.40577012, 0.71335495, 0.7500328 ]])"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.T"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.36349565, 0.71787282, 0.55643619],\n",
       "       [0.62509516, 0.91853055, 0.10764589],\n",
       "       [0.40577012, 0.71335495, 0.7500328 ]])"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.transpose(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Produto interno"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$u \\cdot v$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.29327917230988837"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$A \\cdot u \\equiv Au$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.66800138, 1.17012979, 0.88327025])"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$A \\cdot B \\equiv AB$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.43572615, 0.74847533, 0.38920642],\n",
       "       [0.76300199, 1.26754104, 0.68326889],\n",
       "       [0.48702506, 0.9174937 , 0.53397848]])"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.43572615, 0.74847533, 0.38920642],\n",
       "       [0.76300199, 1.26754104, 0.68326889],\n",
       "       [0.48702506, 0.9174937 , 0.53397848]])"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A @ B"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Produto diádico"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$u \\otimes v$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.08122132, 0.43341142, 0.00383177],\n",
       "       [0.03883841, 0.2072487 , 0.00183228],\n",
       "       [0.1019388 , 0.54396361, 0.00480915]])"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.outer(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$A \\otimes B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.1907415 , 0.11759186, 0.11400616, 0.08943307, 0.14870605,\n",
       "        0.05176902, 0.08168832, 0.33607197, 0.16677801],\n",
       "       [0.32801379, 0.20222003, 0.1960538 , 0.153796  , 0.25572639,\n",
       "        0.089026  , 0.14047753, 0.5779353 , 0.28680433],\n",
       "       [0.2129247 , 0.13126777, 0.12726506, 0.09983411, 0.16600053,\n",
       "        0.05778975, 0.09118865, 0.37515708, 0.18617426],\n",
       "       [0.37669814, 0.23223386, 0.22515242, 0.17662266, 0.29368172,\n",
       "        0.10223939, 0.16132744, 0.66371341, 0.3293723 ],\n",
       "       [0.48199172, 0.2971472 , 0.28808638, 0.22599171, 0.37577079,\n",
       "        0.13081704, 0.20642122, 0.84923266, 0.42143749],\n",
       "       [0.37432743, 0.23077232, 0.22373545, 0.1755111 , 0.29183346,\n",
       "        0.10159595, 0.16031214, 0.65953639, 0.32729943],\n",
       "       [0.29198553, 0.18000866, 0.17451971, 0.13690341, 0.22763801,\n",
       "        0.07924759, 0.12504781, 0.51445625, 0.25530242],\n",
       "       [0.05648634, 0.03482375, 0.03376188, 0.02648478, 0.04403793,\n",
       "        0.01533092, 0.02419124, 0.09952462, 0.04938977],\n",
       "       [0.39357384, 0.24263771, 0.23523903, 0.18453518, 0.30683837,\n",
       "        0.10681961, 0.16855475, 0.69344711, 0.34412785]])"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.outer(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Esse é o produto diádico generalizado. Resulta em matriz de blocos $3 \\times 3$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Produto cruzado"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$u \\times v$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-0.54213133,  0.09810703,  0.39457301])"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cross(u, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Produto de contração tensorial"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$A:B$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(1.74291627)"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.tensordot(A, B)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Característica de Matrizes e condicionamento"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Traço"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.032058999170806"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.trace(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Determinante"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.041970404338626255"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.det(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O determinante ser diferente de zero é uma característica muito desejada quando se tem que resolver um sistema. Ele garante que o sistema é invertível, e portanto tenha solução única."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Número de condicionamento"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "39.59718654379296"
      ]
     },
     "execution_count": 134,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.cond(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O número de condicionamento nos informa a sensibilidade numérica do problema/função/sistema. Um sistema com número de condicionamento baixo não é sensível a erros numéricos que podem se propagar nas manipulações e iterações. Ou seja, é um sistema fácil de se resolver. O problema mal-condicionado é justamente o inverso. São problemas sensíveis e que podem convergir para soluções inadequadas, com muito erro, ou mesmo nem convergir (em métodos iterativos de sistemas). Em geral, dizemos que um sistema com número de condicionamento $\\kappa(A) \\le 1$ (ou próximo de um) é bem condicionado."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Posto de uma matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.matrix_rank(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O posto de uma matriz também é um número muito importante, pois informa quantas linhas linearmente independentes a matriz possui. Podemos usar essa informação para comparar com o número de linhas da matriz. Se for igual, então isso é um indicativo que o sistema é **determinado**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Norma"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8545068183606386"
      ]
     },
     "execution_count": 136,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.norm(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A função `la.norm` calcula a norma de uma matriz ou vetor. Pode ser usada genericamente como `la.norm(A, ord=n)`, sendo `n` a ordem da norma. No caso da norma Euclidiana, `n = 2`, por exemplo. A norma do máximo é dada por:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.3497583103569863"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.norm(A, np.inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "ou, em um vetor:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7155492635807369"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.norm(u, np.inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "que é equivalente a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7155492635807369"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.max()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Autovalores e autovetores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "São fornecidos por uma única função:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 1.69680194, -0.06222866,  0.39748572]),\n",
       " array([[ 0.48460418,  0.81912549, -0.38439744],\n",
       "        [ 0.79042533, -0.21184004, -0.51725859],\n",
       "        [ 0.37468199, -0.53306401,  0.76464512]]))"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e_vals, e_vecs = la.eig(A)\n",
    "\n",
    "e_vals, e_vecs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "sendo cada autovalor dado por `e_vals[i]` e seu correspondente autovetor dado por `e_vecs[:, i]`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Solução de sistemas lineares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As duas funções principais aqui são o solucionador de sistemas e o cálculo da inversa."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Inversa de uma matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[-14.58499921,  10.13005231,  -1.74414509],\n",
       "       [  3.37122449,  -1.11622659,  -0.76220188],\n",
       "       [ 10.33651171,  -7.35510558,   2.73661809]])"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.inv(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "lembrando que isso só é possível já que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "la.det(A) != 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Também podemos facilmente verificar que"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000e+00, -1.09228e-15,  3.18047e-16],\n",
       "       [ 2.63890e-16,  1.00000e+00,  9.63232e-17],\n",
       "       [ 9.89491e-16,  6.48609e-16,  1.00000e+00]])"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.set_printoptions(5)\n",
    "la.inv(A) @ A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.00000e+00,  7.18267e-16, -2.22578e-16],\n",
       "       [-6.17238e-17,  1.00000e+00, -4.98952e-17],\n",
       "       [ 1.46013e-16, -1.39849e-16,  1.00000e+00]])"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A @ la.inv(A)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Solução de sistemas lineares"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos criar um vetor do lado direito com valores fáceis de checarmos a qualidade da solução:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b = np.ones(n)\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agora vamos resolver o sistema $A u = b$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-6.19909,  1.4928 ,  5.71802])"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = la.solve(A, b)\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos verificar que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1.])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Por baixo dos panos, o NumPy utiliza a `_gesv` do LAPACK, que nada mais é do que uma [fatoração LU](https://software.intel.com/sites/products/documentation/doclib/mkl_sa/11/mkl_lapack_examples/dgesv.htm). Pró: é um método direto, portanto fornece uma solução \"exata\", sujeita apenas à precisão da representação numérica empregada. Contra: Pode ser bastante custoso em sistemas grandes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aplicações básicas em Estatística"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A NumPy tem uma grande variedades de funções para Estatística. Não teremos tempo para detalhar aqui neste curso. Esse material demandaria um curso próprio de Análise de Dados com NumPy ou com pandas. Quem tiver interesse, pode verificar as funções disponíveis na [documentação oficial online](https://docs.scipy.org/doc/scipy/reference/stats.html) ou também na página de [rotinas estatísticas básicas](https://docs.scipy.org/doc/numpy-1.15.0/reference/routines.statistics.html).\n",
    "\n",
    "Aqui, veremos só o básico do básico inerente apenas a entrada de valores em vetores e matrizes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Média"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.51943219773322"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Desvio-padrão"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.184342746224072"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.std()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variância"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03398224808543262"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.var()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "que naturalmente é equivalente a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.03398224808543262"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "u.std() ** 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Escrita e Leitura"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "O NumPy oferece rotinas convenientes para leitura e escrita de dados numéricos. Basicamente podemos sobreviver com `loadtxt()` e seu dual `savetxt()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Escrita"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos começar com a escrita, assim poderemos usar o resultado para testar a leitura depois."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Escrita de um único vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('u_out.dat', u)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Vamos agora verificar como ficou o arquivo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.701249488061702619e-01\r\n",
      "2.726223808127529180e-01\r\n",
      "7.155492635807368940e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat u_out.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos ainda mudar o formato da escrita:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('u_out_2.dat', u, fmt='%1.3e')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.701e-01\r\n",
      "2.726e-01\r\n",
      "7.155e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat u_out_2.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Escrita de mais de um vetor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('uv_out.dat', (u, v), fmt='%1.4e')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.7012e-01 2.7262e-01 7.1555e-01\r\n",
      "1.4246e-01 7.6020e-01 6.7209e-03\r\n"
     ]
    }
   ],
   "source": [
    "!cat uv_out.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note que a escrita é feita por linhas. Em cada linha do arquivo de saída, temos um dos vetores. Caso queira salvar cada vetor em uma coluna, basta fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('uv_out_2.dat', np.column_stack((u, v)), fmt='%1.4e')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5.7012e-01 1.4246e-01\r\n",
      "2.7262e-01 7.6020e-01\r\n",
      "7.1555e-01 6.7209e-03\r\n"
     ]
    }
   ],
   "source": [
    "!cat uv_out_2.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Escrita de uma matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Uma matriz nada mais é do que um aglomerado de vetores colunas, então é meio intuitivo como o `savetxt()` irá agir."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('A_out.dat', A, fmt='%1.3e')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.635e-01 6.251e-01 4.058e-01\r\n",
      "7.179e-01 9.185e-01 7.134e-01\r\n",
      "5.564e-01 1.076e-01 7.500e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat A_out.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Só para verificação:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.3635 , 0.6251 , 0.40577],\n",
       "       [0.71787, 0.91853, 0.71335],\n",
       "       [0.55644, 0.10765, 0.75003]])"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos mudar o delimitador simplesmente com"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('A_out_2.dat', A, fmt='%1.3e', delimiter=',')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.635e-01,6.251e-01,4.058e-01\r\n",
      "7.179e-01,9.185e-01,7.134e-01\r\n",
      "5.564e-01,1.076e-01,7.500e-01\r\n"
     ]
    }
   ],
   "source": [
    "!cat A_out_2.dat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "que pode vir a calhar para determinados leitores csv-like."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Leitura"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leitura simples de um vetor em arquivo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.57012, 0.27262, 0.71555])"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = np.loadtxt('u_out.dat')\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leitura de 2 ou mais vetores por linhas"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Aqui apenas com 2 para exemplificar. A extensão para mais é trivial."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.57012, 0.27262, 0.71555]), array([0.14246, 0.7602 , 0.00672]))"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = np.loadtxt('uv_out.dat')\n",
    "\n",
    "x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A leitura aqui foi feita com um array por linha do arquivo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leitura de 2 ou mais vetores por coluna "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.57012, 0.27262, 0.71555]), array([0.14246, 0.7602 , 0.00672]))"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = np.loadtxt('uv_out_2.dat', unpack=True)\n",
    "\n",
    "x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leitura de partes de uma matriz em arrays"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Caso se deseje ler dados em formato matricial de apenas determinadas colunas, basta especificar isso por meio do argumento opcional `usecols`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([0.3635, 0.7179, 0.5564]), array([0.6251, 0.9185, 0.1076]))"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x, y = np.loadtxt('A_out.dat', usecols=(0, 1), unpack=True)\n",
    "\n",
    "x, y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Verificando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.3635 , 0.6251 , 0.40577],\n",
       "       [0.71787, 0.91853, 0.71335],\n",
       "       [0.55644, 0.10765, 0.75003]])"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Leitura de uma matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basta simplesmente fazer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.3635, 0.6251, 0.4058],\n",
       "       [0.7179, 0.9185, 0.7134],\n",
       "       [0.5564, 0.1076, 0.75  ]])"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "M = np.loadtxt('A_out.dat')\n",
    "\n",
    "M"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Próximos passos\n",
    "\n",
    "Acima, vimos apenas as funcionalidades básicas da NumPy e que considero as mais frequentes. Há ainda um mundo todo para explorar! Quer conhecer mais? Sugiro olhar a documentação sempre que precisar realizar alguma tarefa específica."
   ]
  }
 ],
 "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.1"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Conteúdo",
   "title_sidebar": "Conteúdo",
   "toc_cell": true,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}