R-base: algunes idees bàsiques

class: inverse, center, middle

<br>

#### ITA (mòdul pràctic)

## R-base: algunes idees bàsiques

<br>

### Pedro J. Pérez

<br><br>
  
#### e-mail: [pedro.j.perez@uv.es](mailto:pedro.j.perez@uv.es)

---
class: inverse, center, middle

## R-base (algunes idees bàsiques)

#### És molt important *començar* a entendre-les

---
##### Veurem conceptes/idees com:

<br>

- assignació

- tipus de dades

- estructures de dades

- funcions

- paquets: instal·lació i ajuda

<br>

---
class: inverse, center, middle

### Creació d'objectes (assignació)

#### A R, l'assignació es fa, generalment, amb el símbol: .large[<-]

---

##### Creació d'objectes i assignació (.large[<-])

- L'operador d'assignació (`<-`) permet assignar dades/valors a variables/objectes. Amb l'assignació es **creen objectes**/variables que després podrem fer servir en altres operacions.

- És molt més fàcil explicar-ho recolzant-se en exemples:

``` r
#- Quines diferències hi ha entre les següents 2 expressions?
2 + 2
aa <- 2 + 2

#- una vegada hem creat una variable, podem fer-la servir per efectuar nous càlculs
aa + 1

#- podem canviar el valor d'una variable
aa
aa <- 10
aa

#- Què fan les següents línies de codi?
aa <- 2 + 2
bb <- 5 + aa
cc <- 1 + aa * 2
dd <- bb
```

---

##### Sé que t'ha resultat molt fàcil, però torno a insistir-hi:

> A R, la forma genèrica d'una operació d'assignació, o de “creació d'objectes”, és: .white.bg-purple[nom_de l'objecte <- valor] , per exemple .white.bg-purple[aa <- 2 + 2 ] [ 🌟 ]

<br>

- Recorda que perquè un nom sigui **sintàcticament vàlid** a R només pot contenir caràcters alfanumèrics (lletres i números), punts (.) i guions baixos (_).

- A més, hi ha **noms reservats** (TRUE, NA, if, while, do , next, for...)

--------------------------

##### Global environment (primera referència al)

Cada vegada que assignem un nom a un valor, **R crea un nou objecte al Global environment**. Vegem-ho:

``` r
aa <- 2 + 2
bb <- 5 + aa
cc <- 1 + aa * 2
dd <- bb

ls()                #- mostra els objectes q hi ha al Global env.
rm(cc)              #- esborra/elimina l'objecte cc del Global env.
rm(list = ls())     #- esborra tots els objectes del Global env.
```

---
class: inverse, center, middle

### Tipus de dades

#### numèrics (sencers i doubles), lògics i textuals

---

##### Tipus de dades

- Hi ha **3 tipus principals**: numèrics, de text i lògics

- A més, hi ha 4 valors especials: NULL, NA, NaN, i infinit

- Cada dada, valor o variable és dun tipus.

``` r
aa <- "La calle en la que vivo es"    #- text (character)
bb <- 4L                              #- nombre sencer
cc <- 4.3                             #- nombre decimal
dd <- TRUE                            #- logical

typeof(aa)
typeof(dd)
```

<br>

- **IMPORTANT** [ 🌟 ]: El tipus d'una variable determina les operacions que s'hi poden fer.

---

##### Operacions amb variables numèriques

- Operacions aritmètiques

``` r
2 + 2
5 * 6
```

- Operacions de comparació

``` r
2 < 4    # MENOR que: aquesta expressió revisa si 2 és MENOR que quatre. Com és cert, torna TRUE

2 > 4    # MAJOR que: aquesta expressió revisa si 2 és MAJOR que quatre. Com és cert, torna TRUE

5 >= 7   # MAJOR o IGUAL que.
8 <= 8   # MENOR o IGUAL que.

5 == 4   # == IGUAL: == revisa si dos valors són iguals, com no són iguals tornarà FALSE

2 != 4   # NO IGUAL: com que 2 no és igual a 4 ens torna TRUE
5 != 5   # NO IGUAL: com que 5 és igual a 5, ens torna FALSE
```

- Fixa't que les expressions de comparació en ser executades **tornen un “boolean”**: el resultat de la comparació només pot ser TRUE (si l'afirmació és certa) o FALSE.

``` r
2 = 2    #- què passa? per què es queixa R?
```

---

##### Operacions amb text

- A R hi ha moltes funcions per treballar/operar sobre text

- Per exemple, la funció `paste()` ens permet enganxar o concatenar dues variables de tipus character:

``` r
aa <- "mi nombre es"
bb <- "pedro"

paste(aa, bb)

paste(aa, bb, sep = " ... ")

# Prova tu mateix que fa la funció paste0()
```

<br>

``` r
toupper(aa)
tolower(aa)

nchar(bb)                      #- nchar() ens torna el nombre de caràcters d'un string

substring(bb, 2, nchar(bb))    #- substring() extreu caràcters d'un string  [🌶🌶]
```

---

##### Operacions lògiques

- Els 3 principals operadors lògics són: ( **&** ), ( **|**) i ( **!** ). Són els operadors lògics **AND**, **OR** i **NOT**

``` r
TRUE & TRUE    #- AND: perquè torne TRUE cal que TOTES les condicions siguen certes
TRUE & FALSE
FALSE & FALSE

TRUE | TRUE   #- OR: torna TRUE si ALGUNA de les condicions és certa
TRUE | FALSE
FALSE | FALSE

!TRUE         #- NOT: torna el valor contrari
!FALSE
```

``` r
(4 > 3) & (3 < 2)  #- AND: com que només es compleix la primera condició, ens torna FALSE

(1==2) | (2 >3)   #- OR: Com que no es compleix cap de les 2 condicions ens torna FALSE

!(4 > 3)          #- NOT: 4 més gran que 3 és TRUE, però el ! davant d'aquesta condició la nega i passa a FALSE

!!(4 > 3)         #- si negues dues vegades, tornes al principi: TRUE

```

- Hi ha més operadors lògics, per exemple: **xor()**, **all()**, **any()**, **&&** i **||** , però és fàcil que no els fem servir, i si els fem servir ja els veurem.

---
class: inverse, center, middle

## Estructures de dades

#### És molt important!!! [ 🌟 ] però en realitat per al curs n'hi ha prou amb una "lleugera" idea, perquè treballarem (gairebé sempre) amb una sola estructura de dades: els *data.frame*

---

##### Estructures de dades

R serveix per fer anàlisis estadístiques amb dades, i les dades han d'estar emmagatzemades en alguna estructura. Les **principals estructures de dades a R** són:

- vectors

- matrius

- arrays (matrius multidimensionals)

- llistes

- **data.frames**

--------------------------------

- Les que **més utilitzarem** al curs són els **data.frames**, i en segon lloc les llistes.

- Si, **però** en realitat aquestes 2 estructures (data.frames i llistes) són en realitat agrupacions de vectors; és a dir, **l'estructura bàsica, la més important a R són els vectors**.

- Són els més importants perquè la resta d'estructures es construeixen a partir de grups de vectors o afegint-hi alguna propietat addicional, o atribut, a un vector.

---
class: inverse, center, middle

## VECTORS

#### No els utilitzarem gaire-molt, però és l'estructura de dades fonamental

---

##### Vectors

- L'estructura de dades fonamental a R és el vector.

- A R, un vector és una estructura de dades que serveix per emmagatzemar un conjunt ordenat de valors o elements.

- Un vector pot contenir qualsevol número d'elements; tanmateix, **tots els elements han de ser del mateix tipus**. Per exemple, un vector no pot contenir simultàniament números i text.

---

##### Com crear un vector?

- Amb la funció .white.bg-purple[c()]

``` r
aa <- c(3, 22, 6)

aa
is.vector(aa)
typeof(aa)
```

<br>

.panelset[
.panel[.panel-name[Tasca]

.white.bg-green[Tasca]: crea un vector de tipus **character** amb 3 elements

]

.panel[.panel-name[Solució]

``` r
aa <- c("Hola", "número", "9")

is.vector(aa)
typeof(aa)
```

]
]

---

##### Coerció (implicita)

- Sabem que un vector només pot contenir elements d'un tipus (és una **estructura homogènia**)

- Què passa si intentem barrejar en un vector elements de diferent tipus? R convertirà (coureu) els elements perquè siguin del mateix tipus

``` r
aa <- c(4, 6,  "Hola")  #- intentem posar aa elements numèrics i character (?)

is.vector(aa)
typeof(aa)       #- què ha passat?
aa               #- què ha passat?
```

- R convertirà tots els elements al tipus més flexible: **`character > double > integer > logical`**. Per exemple, si al vector hi ha un valor textual, tots els valors es convertiran al tipus character.

##### Coerció (explicita)

- De vegades tindrem un vector d'un tipus, per exemple numèric, però ens agradaria convertir-lo a per exemple character.

``` r
aa <- c(1:4)
aa
aa <- as.character(aa)
aa
```

---

##### Subsetting con vectores

- En R podemos agrupar valores en vectores. Perfecto, pero habrá veces que necesitemos **manipular los vectores**. Por ejemplo necesitaremos acceder a determinados elementos de un vector. Este tipo de operaciones sobre los vectores se les conoce genéricamente como **subsetting**.

- Para hacer subsetting se usan los **corchetes**:  **`[]`**

- Vemos **3 tipos de subsetting**

---

##### 3 tipus de subsetting

###### 1. Seleccionar per posició

``` r
aa <- c(10:1)
aa[c(1:2)]           #- primer i segon element del vector

aa[c(1, 2, 9, 10)]   #- dos primers i 2 darrers elements
```
  
--
 
###### 2. Eliminar per posició

``` r
aa <- c(10:1)
aa[-2]

aa[- c(1, 2, 9:10)]
```
  
--

###### 3. Subsetting lògic

``` r
aa <- 1:10
aa[aa >= 7]
aa[aa < 4]

aa[(aa >= 9) | (aa < 2)]
aa[(aa >= 9) & (aa < 2)]
```

---

##### Intenta entendre bé el següent chunk. És important!!

``` r
aa <- 1:10

aa <= 4
aa[aa <= 4]
aa <- aa[aa <= 4]
aa
```
  
--

##### Modificar elements d'un vector

``` r
aa <- c(1:10)
aa[4] <- 88             #- el quart element de aa prendrà el valor 88
aa <- c(aa, 111, 112)   #- afegim 2 elements al vector aa
```

##### Els vectors es poden concatenar

``` r
aa <- c(1:5)
bb <- c(100:105)
cc <- c(aa, bb)
```

---

##### Operacions amb vectors

- Generalment són operacions element a element

``` r
aa <- 1:10
bb <- 1:10

aa + bb
aa * bb
```

<br>
 
--

--------------------------------------------------

#####  Recycling

``` r
aa <- 1:10
aa + 1
```

---

##### Funcions vectoritzades

- La majoria de funcions, i tots els operadors de R estan vectoritzats; és a dir, si una funció rep com a input un vector, s'aplicarà la funció a cadascun dels elements del vector.

``` r
aa <- c(4, 9, 25)

sqrt(aa)
```

<br>

-----------------------------

##### Operacions de comparació

- També estan vectoritzades

``` r
aa <- 1:3
bb <- 3:1

aa == bb
aa >= bb
aa != bb
```

---
class: inverse, center, middle

## LLISTES

#### Veurem una mica, però més endavant

---
class: inverse, center, middle

## DATA FRAMES

#### Estarem tots el curs treballant amb DATA FRAMES

---

##### DATA FRAME's

- Són una altra **estructura de R per emmagatzemar dades**. S'utilitza per emmagatzemar dades tabulars, taules de dades

<br>

- Un data.frame (df) és una agrupació de vectors amb la mateixa longitud, de manera que al final tenim una taula de dades, on **cada columna serà una variable**

<br>

- Una altra propietat dels data.frames és que els seus vectors (o columnes) han de tenir un nom, que serà el nom de la variable.

---

##### Creació de data frame's

- Generalment no crearem data.frames sinó que els importarem de repositoris de dades, per exemple d'Eurostat o de l'INE, però avui sí que en crearem un amb la funció, es fa amb la funció **`data.frame()`* *

``` r
#- creem 3 vectors de la mateixa longitud
aa <- c(4, 8, 6, 3)
bb <- c("Juan", "Paz", "Adrian", "Marquitos")
cc <- c(FALSE, TRUE, TRUE, FALSE)

#- agrupem els 3 vectors en un data.frame
df <- data.frame(aa, bb, cc)

#- vegem el data.frame. Veurem que les columnes tenen nom
df
```

<br>

- Podem posar altres noms a les columnes, noms que tinguin sentit perquè ens recordin les variables que contenen a cada columna:

``` r
df <- data.frame(Nota = aa, Nombre = bb, Aprobado = cc)
```

---

##### Subsetting en data frames

Generalment, quan haguem de fer subsetting en un data frame, ho farem **à la tidyverse**, però convé almenys conèixer allò bàsic de com fer subsetting amb R-base.

Diverses formes de subsetting:

- com si fos una matriu, usant el claudàtor; o sigui, **amb [**.

- com si fos una llista. De fet, un df és una classe especial de llista. **Podem fer servir 3 operadors: [, [[ i $**.

<br>

------------------------------

##### subsetting com si fos una matriu: amb [ ]

``` r
df_s <- df[,1]        #- seleccionem la primera columna
df_s <- df[,c(2,3)]   #- seleccionem la segona i tercera columna
df_s <- df[1, ]       #- seleccionem primera fila de totes les variables.
df_s <- df[c(1,4), ]  #- seleccionem primera i quarta fila
df_s <- df[2, 3]      #- ¿?
```

---

##### data.frames: subsetting como si fuera una lista: amb [, [[ i  $

#### Com llista amb [

- sempre torna un df

``` r
df_s <- df[3]       
df_s <- df[c(1,2)]

#- també es pot fer per nom
df_s <- df["Name"]              
df_s <- df[c("Name", "Grade")]   
```

#### Com a llista amb [[

``` r
df_s <- df[[2]]   #-  Extraiem la segona columna
```

#### Com a llista amb $

``` r
df_s <- df$Name   #- Extraiem la columna amb nom "Name".

df_s <- df$Grade  #-  Extraiem la columna amb nom "Grade". 
```

---
class: inverse, center, middle

# FUNCIONS

#### Potser el més important del curs és entendre bé com "funciona" una funció

---

##### Entendre què és una funció i ...

##### ... com “funciona una funció” és molt important!!!

<br>

- Repeteixo, és molt important entendre què és i com fer servir una funció. De fet, tot el que passa a R és perquè has fet una crida a una funció, has fet una “function call”.

<br>

- **Què és una funció?** Una funció no és més un tros de codi R, unes instruccions de R, a les quals hem assignat un nom; aleshores, quan invoquem aquest nom s'executaran aquestes línies de codi. (!!!)

<br>

- Com que no crec que això us digui molt, faré servir 5 minuts per crear la nostra primera funció. Anem a R.

---

##### Creem la nostra primera funció [🌶🌶🌶]

.panelset[
.panel[.panel-name[Tasca]

.white.bg-green[Tasca]: crea una funció que permeta sumar 2 números

]

.panel[.panel-name[Pistes]

**Pista**: Les funcions en R es creen amb la funció anomenada `function()`. Sí, una mica embarbussaments.

**Pista**: La funció que crearem serà un objecte de R, així que us hem d'assignar un nom

**Pista**: Els arguments de la funció van dins dels parèntesis separats per comes

**Pista**: El codi que vulguem que s'executi quan truquem a la funció va entre claus (llaves)

<br>

Per tant, en genèric, una funció a R es crea així:

```
nombre_de_mi_funcion <- function(primer_argumento, segundo_argumento, ...) {
  <el-codigo-q-quiero-q-se-ejecute-cuando-se-invoque-a-la-función>
}
```

<br>

**Sí ho aconseguiu sou genis/gènies** o ja heu vist això en un altre llenguatge

]
.panel[.panel-name[Solució]

``` r
#- creem una funció anomenada "my_suma()". Ho fem amb la funció de R anomenada "function()"

my_suma <- function(n1 , n2){
  n1 + n2
}

#- per utilitzar la funció que hem creat,
#- hem de trucar a la funció my_suma() i passar-li els arguments que necessita

my_suma(3 , 5)

my_suma(n1 = 3 , n2 = 5)

aa <- my_suma(30 , 50)
```

]
]

##### entens millor ara què és una funció?

- Després d'haver creat la nostra primera funció, jo crec que ara entendràs millor que una funció no és més que un tros d'instruccions/codi a R que algú ha creat per ser usada. Només hem d'invocar-ne el nom i donar valors als seus arguments.

---

##### seguim amb les funcions

- Aprofundirem en el nostre coneixement de les funcions usant una nova funció, la funció `sqrt()`. Resulta que algú s'ha preocupat de construir una funció anomenada `sqrt()` que serveix per calcular arrels quadrades. La farem servir!! Com??

---------------------------

##### saber consultar l'ajuda d'una funció is VERY important [ 🌟 ]

- Per saber com fer servir una funció el que cal fer és **consultar l'ajuda de la funció**; sí, cada funció de R té una pàgina d'ajuda interna.

- Per obrir l'ajuda d'una funció has de situar el cursor al nom de la funció i fer clic a .white.bg-purple[F1]. També podeu fer:

``` r
help(sqrt)
```

- Pufff!!! l'ajuda de la funció sembla molt complicada. Sí, això sembla: cal aprendre a llegir les ajudes de les funcions. **Això és MOLT IMPORTANT!!!!** si vols aprendre a manejar-te amb R. De seguida ho veiem

---

##### seguim amb les funcions

- Encara que no ho entenguis del tot, has de saber que, quan utilitzarem una funció, la seva estructura és: .white.bg-purple[nom_de_la_funcio(argument_1, argument_2, ....) ] . Després tornarem a aquest punt.

<br>

- .white.bg-green[Tasca:]Executa aquestes instruccions i intenta entendre què passa.

``` r
sqrt(9)

sqrt(9, 4)   #- no funciona, per què? quants arguments té la f. sqrt()?

sqrt("9")    #- no funciona, per què? de quin tipus ha de ser l'argument?
```

<br>

---

##### seguim amb les funcions (més detalls) [🌶🌶🌶]

- En realitat, quan farem servir una funció, **cada argument de la funció té 2 elements**: el **nom** de l'argument i un **valor** per a l'argument
  
```
nombre_de_la_funcion(name_argumento_1 = valor_1, name_argumento_2 = valor_2, ....)
```

--
- El nom de la funció sqrt() és `sqrt`, ok, però quins són els seus arguments? L'ajuda ens diu que només té un argument, el nom del qual és x; a més, el valor de l'argument ha de ser numèric. (!!!).

``` r
sqrt(9)       #- en realitat "no cal" posar el nom de l'argument
sqrt(x = 9)   #- 
sqrt(x = 4)
```

--------------------------

- Aprendrem a diferenciar el nom i el valor de l'argument d'una funció:

``` r
sqrt(9)
sqrt(x = 9)

x <- 25
sqrt(x)

sqrt(x = x)          #- !!! quin és el nom i el valor de l'argument?
sqrt(x = un_valor)   #- !!! què passa?
sqrt(nn = 9)         #- !!! què passa?
```

---

##### seguim amb les funcions (ja casí ho tenim!!)

- .white.bg-green[Tasca:] calcular amb R el logaritme de 1000 a la base 10.

Per això heu d'usar la funció log(), i com no sabeu com es fa servir, no sabeu com és la seva sintaxi, no sabeu quins són els seus arguments, us tocarà **mirar l'ajuda de la funció**.

.panelset[
.panel[.panel-name[Tasca]
    
- Vinga, que us ajudo: `log(1000)` no funcionarà. Per què? per saber-ho hauràs de mirar l'ajuda de la funció `log()`

``` r
help(log)
```
]

.panel[.panel-name[Solució]

``` r
log(1000)  #- com que no especifiquem el valor de l'argument "base",
           #- R el fixa al valor x defecte; és a dir, base = exp(1)
           #- així que estem prenent logaritmes naturals
```

``` r
log(x = 1000, base = 10)    #- GOOD

log(1000, base = 10)        #- és equivalent
log(x = 1000, 10)           #- és equivalent
log(1000, 10)               #- és equivalent

log(1000, bas = 10)         #- funciona, però ...
```

Per què no podem fer servir l'expressió de debaix?

``` r
log(10, 1000)
```

``` r
log(base = 10, 1000)
```

]
]

-
---
class: inverse, center, middle

## Paquets: instal·lació i ajuda

#### És important entendre la diferència entre paquets a CRAN i en altres repositoris, i sobretot saber buscar l'ajuda d'un paquet.

---

##### Paquets (primeres idees)

<br>

- **Què són els paquets?** trossos/porcions de codi R que podem **instal·lar** al nostre ordinador

- **Què guanyem instal·lant un paquet?** Els paquets ens proveeixen de noves funcions o noves dades; és a dir incrementa la funcionalitat de R: per exemple, amb el pkg `meme` podem fer mems.
<br>

--
- Els paquets solen estar a **repositoris**

- R té un **repositori oficial** anomenat [**CRAN**](https://cran.r-project.org/). Ara mateix te 16.273 paquets. [Aquí](https://cran.r-project.org/web/packages/index.html) podeu veure el llistat de paquets ordenats alfabèticament i per data, i [aquí](https://cran.r-project .org/web/views/) ordenats per tòpic.

- Hi ha altres repositoris: Github, Gitlab, Bioconductor, ...

---

##### Com m'instal·lo un paquet? (Forma habitual)

- Per instal·lar un **paquet que està a CRAN** cal fer servir:

``` r
install.packages("dplyr")    #- instal·lem el pkg dplyr al nostre ordinador
library(dplyr)               #- carreguem dplyr en memòria de R per així poder utilitzar-lo
```

- Per instal·lar un **paquet que està a GitHub** cal tenir instal·lat el paquet `remotes` o el paquet `devtools` i fer:

``` r
install.packages("remotes")    #- #- prèviament cal instal·lar el pkg remotes
remotes::install_github("tidyverse/dplyr")   #- instal·lem la versió de github del pkg dplyr
```

----------------------------

<br>

- Recorda que els paquets es **instal·len una sola vegada**, però que cada cop que vulguem usar-lo cal "carregar-lo" en memòria amb `library()`

``` r
library(dplyr)    #- carreguem dplyr en memòria de R per així poder utilitzar-lo
```