00_Intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "loved-terry",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "<a href=\"http://www.unioeste.br\"><img src=\"https://www5.unioeste.br/portalunioeste/templates/tlpcampus/images/logoUnioeste.png\" align=\"right\"></a>\n",
    "\n",
    "<h1><center>Uma breve introdução à linguagem R</center></h1>\n",
    "\n",
    "<center>Prof.Dr. Plinio Andrade</center>\n",
    "\n",
    "<b> <font color='red'>ATENÇÃO!</font></b> sempre que este notebook for reaberto você deverá executar todas as células de código novamente. Cada célula **ativa** é executada pressionando o botão <b>Run</b> no menu da parte superior da tela, ou teclando <b>Ctrl+Enter</b>.\n",
    "\n",
    "Download do R: https://www.r-project.org/\n",
    "\n",
    "Interface RStudio (opcional): https://www.rstudio.com/products/rstudio/\n",
    "\n",
    "Neste roteiro, você aprenderá a:\n",
    "\n",
    "* realizar operações aritméticas no R;\n",
    "* construir vetores, matrizes e dataframes;\n",
    "* definir variáveis (objetos);\n",
    "* identificar os diferentes tipos de dados.\n",
    "\n",
    "**IMPORTANTE:** \n",
    "\n",
    "- Os decimais no R são separados por ponto e não por vírgula. A vírgula é utilizada como separador em outras estruturas. Por exemplo, o número $0,263$ deve ser informado no R como ```0.263```.\n",
    "\n",
    "- Sempre que houver dúvida sobre alguma função do R (p.ex. função ```plot()```), utilize o código ```?plot``` para abrir uma página com a documentação desta função. Se a pesquisa for ampla, utilize ```??plot``` para buscar por todos os tópicos que possuem a palavra \"plot\".\n",
    "\n",
    "## Parte 1: Operações aritméticas no R\n",
    "\n",
    "Os operadores ```+```, ```-```, ```/```, ```*``` ```^``` realizam operações de adição, subtração, divisão, multiplicação e potenciação respectivamente (somente para números). Execute as células a seguir para visualizar os resultados:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bigger-three",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "3+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "confused-cargo",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "3-5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "enormous-tooth",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2/3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "enhanced-syracuse",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "4*2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "superior-tension",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2^3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "downtown-flesh",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "As operações podem ser combinadas, respeitando a ordem usual:\n",
    "\n",
    "* 1º Parêntesis;\n",
    "\n",
    "* 2º Expoentes;\n",
    "\n",
    "* 3º Multiplicações e Divisões; (da esquerda para a direita)\n",
    "\n",
    "* 4º Somas e Subtrações. (da esquerda para a direita)\n",
    "\n",
    "Suponha que se queria calcular o quociente entre a soma $3+5$ e a potência $2^4$. Note que:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "congressional-documentary",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "3+5/2^4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "olympic-tours",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "é equivalente a:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "closed-zoning",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "3+(5/2^4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "twenty-suite",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Em ambos os casos, o objetivo não foi alcançado. **Na dúvida, utilize parêntesis para evitar erros!** Observe que o código a seguir entrega a operação desejada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "exotic-edmonton",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "(3+5)/(2^4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "sapphire-mountain",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Caso a potenciação tenha como base o *número de Euler* ($e=2,71828\\ldots$), podemos utilizar a função ```exp()```. Por exemplo, suponha que se queira calcular\n",
    "\n",
    "$$e^{1/2}$$\n",
    "\n",
    "Basta fazer:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "educated-arbitration",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "exp(1/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "medieval-xerox",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Recorde que a **radiciação** pode ser vista como uma operação de potenciação. Por exemplo,\n",
    "\n",
    "$$2=\\sqrt{4}=4^{1/2},$$\n",
    "\n",
    "de fato:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "rational-bicycle",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "4^(1/2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "presidential-rogers",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Podemos também usar uma função pronta (que funciona apenas para raízes quadradas):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "affecting-despite",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "electrical-dating",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Para calcular logaritimos, podemos recorrer à algumas funções do R como veremos a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "trying-marker",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "log(2)    # logaritmo natural de 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "civilian-ordinary",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "log10(2)  # logaritmo de 2 na base 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "japanese-legislation",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "log(2, 5) # logaritmo de 2 na base 5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "prime-vienna",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Parte 2: Vetores e operadores lógicos\n",
    "\n",
    "Vetores são conjuntos de valores ordenados. No R, estes podem ser formados por números ou caracteres. O operador ```:``` cria uma sequência a partir de um número até o outro, enquanto a função ```c``` concatena valores, retornando um vetor. Exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "demonstrated-nerve",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2:7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "false-antique",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(2,3,4,5,6,7)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "attached-marsh",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Diversas operações podem ser feitas com vetores e entre vetores. Observe alguns exemplos:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "limiting-winner",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2:7 + 8:13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "related-bangkok",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(2,3,4,5,6,7) + c(8,9,10,11,12,13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lyric-director",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(2,3,4,5,6,7) + 8:13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "described-journey",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(2, 3, 5, 7, 11, 13) - 2  # subtração"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "expired-wales",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "-2:2 * -2:2                # multiplicação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aging-british",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "(1:10)^2                   # exponenciação"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "pleasant-friendship",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "1:10 / 3                   # divisão"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "headed-guest",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "A igualdade entre dois valores ou dois vetores pode ser estudada por meio do operador ```==``` (note que são dois sinais de igual). No caso da diferença, utiliza-se o operador ```!=```."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "comparable-exclusive",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2 == 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "executed-obligation",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(3, 4 - 1, 1 + 1 + 1) == c(3, 3, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "peripheral-casting",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(1,2,3) != c(3,2,1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "derived-thriller",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "No R, os caracteres devem ser informados entre aspas, por exemplo, o caractere ```categoria 1``` deve ser infomado como ```\"categoria 1\"```. Note que o R reconhece letras maiúsculas e minúsculas:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "induced-cruise",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(\"A\", \"B\", \"C\") == c(\"A\", \"b\", \"d\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "talented-criterion",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Operações do tipo *maior*, *menor*, *maior ou igual* ou *menor ou igual* são feitas utilizando os operadores ```>```, ```<```, ```>=``` ou ```<=``` respectivamente. Observe os exemplo a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "known-fireplace",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2>4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "architectural-limitation",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "2>=2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "destroyed-municipality",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "exp(1:5) < 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "verified-geology",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(1,2,3) >= c(1,5,6)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "thrown-schema",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Parte 3: Definindo variáveis\n",
    "\n",
    "Existem diversas situações onde o resultado de uma operação ou função será utilizada várias vezes. Nestes casos, é interessante armazenar tais resultados em variáveis (ou objetos). Para isso, utiliza-se o operador ```<-``` ou o sinal de igual ```=```. Ou seja, um código do tipo ```a <- 10```, significa que uma variável rotulada como ```a``` ficará armazenada na memória com o valor ```10```, e sempre que ```a``` for digitado e executado, o valor ```10``` será exibido. Quando fizer sentido, podemos fazer operações entre variáveis e aplicá-las em funções. Observe os exemplos a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "vertical-verse",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "a <- 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "jewish-relief",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "b <- 3 * 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dramatic-american",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "x <- 1:5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "transparent-television",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "y <- c(0.2, exp(1), pi, 0.05, 10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bronze-cedar",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "prescription-reducing",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "weighted-undergraduate",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "secret-marketplace",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "naval-lawsuit",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "a + 2 * b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cubic-location",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "x + (2 * y) - 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "copyrighted-baking",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Note que o R já identifica ```a``` e ```b``` como números e ```x``` e ```y``` como vetores. Além disso, o R suporta quatro valores especiais de números: ```Inf```, ```-Inf```, ```NaN``` e ```NA```. Os dois primeiros representam *infinito positivo* e *infinito negativo*, ```NaN``` é um acrônimo em inglês para \"not a number\", ou seja, *não é um número*, aparecendo quando um cálculo não faz sentido ou é uma indeterminação matemática. Por fim, o valor ```NA``` significa \"not available\", ou seja, *não disponível*, e representa um valor faltante."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "electric-slave",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(Inf + 1, Inf - 1, Inf - Inf, NA + 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "stupid-batman",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "c(0 / 0, Inf / Inf, 1 / Inf)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "controversial-paper",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Valores lógicos podem ser armazenado em variáveis e operações lógicas podem ser conduzidas (mas não vamos entrar nestes detalhes). Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "forbidden-recipient",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "z <- 1:10 >= 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "super-treaty",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "changing-treaty",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Pode ser necessário acessar valores específicos de um vetor. Por exemplo, suponha que se queira acessar o terceiro elemento do vetor ```y``` previamente armazenado. Isso pode ser feito da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "designing-leeds",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "y[3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sixth-updating",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "y[-3] # todos os elementos de y menos o terceiro"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "growing-obligation",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Podemos utilizar um vetor de índices para acessar as componentes correspondentes de um vetor. Por exemplo, podemos acessar o primeiro, terceiro e quinto valor do vetor ```y``` da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "appointed-fishing",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "y[c(1,3,5)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "incredible-terminology",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "y[c(-2,-4)] # forma alternativa"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "intermediate-canon",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "O número de elementos de um vetor pode ser obtido por meio da função ```length()```. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "stunning-selling",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "length(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "flying-encoding",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "length(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "romance-overhead",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Cada variável do R possui uma classe. Podemos descobrir a classe de uma variável por meio da função ```class()```. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "sorted-postage",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "lucky-teens",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "inappropriate-hanging",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "available-reset",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ambient-medicare",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "palavras <- c(\"Aprender\", \"R\", \"é\", \"divertido!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dense-atlantic",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(palavras)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "roman-check",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Para saber quais variáveis estão armazenadas na memória, basta digitar o comando ```ls()```. Para remover uma variável utilize a função ```rm()```. Por exemplo:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ongoing-currency",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "ls()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "mathematical-table",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "rm(palavras)    # remove a variável \"palavras\" (verifique!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "drawn-local",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "rm(list = ls()) # remove todas as variáveis! Cuidado!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "spread-differential",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "## Parte 4: Matrizes e dataframes\n",
    "\n",
    "Uma matriz pode ser pensada como um vetor em duas dimensões. Vamos criar a seguinte matriz no R:\n",
    "\n",
    "$$\n",
    "A=\\begin{pmatrix}\n",
    "1 & 5 & 9\\\\\n",
    "2 & 6 & 10\\\\\n",
    "3 & 7 & 11\\\\\n",
    "4 & 8 & 12\n",
    "\\end{pmatrix}\n",
    "$$\n",
    "\n",
    "Podemos concatenar as linhas (ou colunas) da matriz $A$ em um único vetor que será passado para a função ```matrix()``` do R. Veja a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "solid-oliver",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A <- matrix(1:12, nrow = 4) # no lugar de nrow = 4 podemos informar ncol = 3 (verifique!)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "blocked-timothy",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "competent-pennsylvania",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(A) # classe do objeto A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "celtic-singles",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Em algumas situações, pode ser importante nomear as linhas e/ou colunas de uma matrix. Veja como fazer isso a seguir:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "random-grade",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "linhas  <- c(\"L1\", \"L2\", \"L3\", \"L4\")\n",
    "colunas <- c(\"C1\", \"C2\", \"C3\")\n",
    "A <- matrix(1:12, nrow = 4, dimnames = list(linhas, colunas))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "previous-marriage",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "adaptive-waste",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Vejamos alguns comandos para obter informações sobre uma matriz:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "missing-impact",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "dim(A)    # retorna a dimensão da matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "developmental-input",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "nrow(A)   # retorna o número de linhas da matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "modular-hughes",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "ncol(A)   # retorna o número de colunas da matriz"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "accomplished-finance",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "length(A) # retorna o número de elementos da matriz"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "numerous-major",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Podemos fazer operações com matrizes como soma, multiplicação, multiplicação por escalar, matriz transposta, matriz inversa (quando possível), etc. Não entraremos em detalhes sobre isso agora.\n",
    "\n",
    "Assim como foi feito com os vetores, podemos acessar elementos ou partes de uma matriz. No entanto, devemos informar dois índices. Por exemplo, o elemento $6$ está na segunda linha e segunda coluna da matriz $A$. Assim, para acessá-lo, devemos proceder da seguinte maneira:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "metallic-lecture",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A[2,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "decent-european",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Para acessar uma linha de uma matriz, basta informar apenas o índice correspondente à linha e deixar o índice correspondente à coluna em branco. Por exemplo, vamos acessar a terceira linha da matriz $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "trying-seventh",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A[3,]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "tracked-remains",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "O mesmo raciocínio vale para acessar colunas. Vamos acessar a segunda coluna da matriz $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "honest-variance",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A[,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "elder-count",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Existem várias maneiras de acessar \"submatrizes\" de uma matrix. Por exemplo, vamos acessar apenas os valores das duas últimas linhas e duas últimas colunas de $A$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "unable-brisbane",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "A[3:4,2:3]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "interested-treasury",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Vetores e matrizes devem conter elementos do mesmo tipo (números, caracteres, elementos lógicos). Um **dataframe** permite o armazenamento de diferentes tipos de dados, cada um em uma coluna. Vamos criar um dataframe a seguir cujas colunas terão os rótulos x, y, z, w e n, cada um com um tipo diferente de dado e com 10 elementos cada:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "weighted-plaza",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "df1 <- data.frame(\n",
    "   x = letters[1:10],\n",
    "   y = rnorm(10),\n",
    "   z = runif(10) > 0.5,\n",
    "   w = rpois(10,3),\n",
    "   n = 1:10\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "serial-discovery",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "df1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "derived-bible",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Observe alguns comandos a seguir que podem ser utilizados para obter informações de um dataframe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "positive-kinase",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "class(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "funky-desperate",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "rownames(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "different-switch",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "colnames(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dependent-oklahoma",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "dim(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "binding-armor",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "nrow(df1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "monetary-norman",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "ncol(df1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "registered-marathon",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "A seleção dos elementos de um dataframe pode ser feita de forma análoga ao das matrizes. Observe:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "laughing-romance",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "df1[2,2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "naughty-federal",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "Podemos selecionar uma determinada coluna pelo seu nome, utilizando o símbolo ```$``` após o nome do dataframe seguido do rótulo da coluna. Por exemplo, vamos selecionar todos os elementos da coluna ```z```:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cordless-press",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "df1$z"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "angry-opera",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "O objeto ```df1$z``` é um vetor, logo, podemos selecionar um elemento ou partes dele como vimos anteriormente:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "important-approval",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "outputs": [],
   "source": [
    "df1$z[2:4]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "judicial-douglas",
   "metadata": {
    "deletable": false,
    "editable": false
   },
   "source": [
    "### Até a próxima!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "R",
   "language": "R",
   "name": "ir"
  },
  "language_info": {
   "codemirror_mode": "r",
   "file_extension": ".r",
   "mimetype": "text/x-r-source",
   "name": "R",
   "pygments_lexer": "r",
   "version": "3.6.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}