Funzioni

R mette a disposizione numerose funzioni. Inoltre, è possibile scaricare, installare e richiamare delle librerie esterne, che mettono a disposizione altri insiemi di funzioni.

Per iniziare a giocare con R, introduciamo le funzioni length, min, max, sum, mean.

  • length(v) serve per conoscere la lunghezza (il numero di elementi) del vettore v.
  • min(v) ritorna il valore più basso di un vettore v, max() il più alto.
  • sum(v) somma i valori del vettore. prod(v) calcola il prodotto dei valori.
  • mean(v) calcola la media, sd(v) la deviazione standard
variabile1 <- c(2,3,6,4,8,4,1)
length(variabile1)

## [1] 7

min(variabile1)

## [1] 1

max(variabile1)

## [1] 8

# somma tutti i valori
sum(variabile1)

## [1] 28

# moltiplica tutti i valori
prod(variabile1)

## [1] 4608

# mean calcola la media
mean(variabile1)

## [1] 4

# sd calcola la deviazione standard
sd(variabile1)

## [1] 2.380476

Generare delle sequenze

La funzione seq genera delle sequenze. La sintassi più semplice, seq(from,to) crea una sequenza dal primo valore all'ultimo con step 1. Il comando c(from:to) è del tutto equivalente, ed utilizza il cosiddetto Colon Operator.

seq(0,1000, length=11) genera una sequenza di 11 numeri da 0 a 1000: 0, 100, 200 ... 1000.

(vettore1 <- seq(1,10))

##  [1]  1  2  3  4  5  6  7  8  9 10

# seq (n) è uguale a seq(1,n)
seq(10)

##  [1]  1  2  3  4  5  6  7  8  9 10

# c(a:b) == seq(a,b)
c(1:10)

##  [1]  1  2  3  4  5  6  7  8  9 10

# genera una sequenza di lunghezza length
seq(0,1000, length=11)

##  [1]    0  100  200  300  400  500  600  700  800  900 1000

Ripetizione

La funzione rep(v,n) ripete un vettore n volte.

# ripete 2 10 volte
rep(2,times=10)

##  [1] 2 2 2 2 2 2 2 2 2 2

rep(c(2,4),times=10)

##  [1] 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4 2 4

# crea un vettore di lunghezza 10
rep(c(2,4),length=10)

##  [1] 2 4 2 4 2 4 2 4 2 4

# concateno due sequenze
sequenze1 <- c(seq(0,1000, length=11),seq(1000,0, length=11))
sequenze1

##  [1]    0  100  200  300  400  500  600  700  800  900 1000 1000  900  800  700  600  500  400  300  200  100    0

  • rep(c(2,4,3),times=10) ripete 10 volte i valori 2, 4 e 3, creando un vettore di 30 elementi.

  • rep(c(2,4),length=10) crea un vettore di lunghezza 10.

  • rep_len(x, n) equivale a rep(x,length=n)

  • R: Replicate Elements of Vectors and Lists

sample

La funzione sample(v,n) estrae n valori, in ordine casuale, dal vettore v.

sample estrae casualmente i valori dal vettore - la metafora è quella di un'urna da cui vengono estratti i numeri. Se replace=FALSE un valore estratto non viene re-immesso nell'urna. Con replace=TRUE viene re-immesso, e può essere estratto di nuovo.

sample(v) può essere usata per mescolare l'ordine del vettore v.

# mescola il vettore
(mischiato <- sample (vettore1))

##  [1]  3  5  2  6  8  1 10  4  7  9

# sample (v,n) fa il sample e restituisce i primi n numeri
sample(vettore1, 4)

## [1] 9 8 2 7

# se lo rifaccio, avrò numeri differenti
sample(vettore1, 4)

## [1]  3  4 10  9

# con replace = TRUE i valori estratti vengono rimessi nell'urna
sample(1:4,10,replace = TRUE)

##  [1] 4 2 2 4 4 1 3 2 1 2

Ordinare un vettore

# ordina un vettore
# decreasing = TRUE ordine decrescente
sort(mischiato)

##  [1]  1  2  3  4  5  6  7  8  9 10

order(mischiato)

##  [1]  6  3  1  8  2  4  9  5 10  7

mischiato[order(mischiato)]

##  [1]  1  2  3  4  5  6  7  8  9 10

sort(mischiato) ordina il vettore, dal valore minore al maggiore.

sort(mischiato,decreasing=TRUE) per l'ordine inverso.

order(mischiato) ritorna la permutazione necessaria per ordinare mischiato

Rev

rev(v) rovescia l'ordine degli elementi del vettore.

# rev(x) gira x
rev(vettore1)

##  [1] 10  9  8  7  6  5  4  3  2  1

rev(mischiato)

##  [1]  9  7  4 10  1  8  6  2  5  3

cbind, rbind

cbind e rbind creano delle matrici legando vettori o matrici in colonne (cbind) o in righe (rbind).

# rbind prende gli argomenti e li mette una riga dopo l'altra
rbind(c(1,2),c(3,4),c(5,6))

##      [,1] [,2]
## [1,]    1    2
## [2,]    3    4
## [3,]    5    6

# incolonna gli argomenti
cbind(c(1,2),c(3,4),c(5,6))

##      [,1] [,2] [,3]
## [1,]    1    3    5
## [2,]    2    4    6

all, any

all(v) e any(v) possono essere interpretate come delle estensioni degli operatori logici & e | (and e or).

all(v) restituisce TRUE solo se tutti i valori del vettore logico v sono veri. any(v) restituisce TRUE se almeno uno dei valori del vettore logico v sono veri.

# l'operatore logico & equivale alla funzione all (con 2 argomenti)
TRUE & FALSE

## [1] FALSE

all(TRUE,FALSE)

## [1] FALSE

# l'operatore logico | equivale alla funzione any (con 2 argomenti)
TRUE | FALSE

## [1] TRUE

any(TRUE,FALSE)

## [1] TRUE

(logico1 <- mischiato>5)

##  [1] FALSE FALSE FALSE  TRUE  TRUE FALSE  TRUE FALSE  TRUE  TRUE

all(logico1)

## [1] FALSE

any(logico1)

## [1] TRUE

Operazioni su insiemi

Operazioni di intersezione, unione, differenza, uguaglianza di insiemi.

Gli insiemi sono una lista non ordinata di elementi unici (che non si ripetono). Pertanto in queste operazioni vengono considerati i valori unici presenti nei vettori, e non viene considerato l'ordine degli elementi.

(vettore2 <- c(seq(6,15),rep(8,3)))

##  [1]  6  7  8  9 10 11 12 13 14 15  8  8  8

(vettore3 <- sample(1:10))

##  [1]  4  2  3 10  1  6  9  5  7  8

# intersect (v1, v2) restituisce i valori in comune, senza ripetizioni
intersect(vettore2, vettore3)

## [1]  6  7  8  9 10

# tutti i valori che appaiono almeno una volta 
# nell'unione dei due vettori, senza ripetizioni
union(vettore2, vettore3)

##  [1]  6  7  8  9 10 11 12 13 14 15  4  2  3  1  5

# setdiff(v1,v2): i valori di v1 NON presenti in v2
setdiff(vettore2, vettore3)

## [1] 11 12 13 14 15

# restituisce TRUE se i due vettori hanno gli stessi elementi
setequal(vettore2, vettore3)

## [1] FALSE

# perché?
setequal(c(2,4,5,6), c(4,2,5,6,5,2))

## [1] TRUE

Aritmetica delle matrici

R permette sofisticate operazioni di aritmetica dei vettori e delle matrici. Riportiamo gli esempi più semplici.

vettore1 <- c(1:9)
vettore1*2

## [1]  2  4  6  8 10 12 14 16 18

Apparentemente, vettore1*2 moltiplica vettore1 per lo scalare 2. In realtà, 2 non è uno scalare, ma un vettore di lunghezza 1, che viene riciclato per la lunghezza di vettore1. La logica diviene evidente se moltiplichiamo vettore1 per un vettore di lunghezza 3.

vettore2 <- c(1,2,3) 
vettore1*vettore2

## [1]  1  4  9  4 10 18  7 16 27

Come si può vedere, vettore2 è stato riusato 3 volte per moltiplicare vettore1.

Questa operazione viene definita element-wise multiplication, e si distingue dalla moltiplicazione di matrici, che si ottiene con la sintassi A %*% B, ma che qui non verrà trattata.

Vediamo alcuni esempi con le matrici

matrice1 <- matrix (
	c(5,7,1,6,9,5,2,1,9,5,7,5), 
	nrow =3, ncol=4)
matrice1

##      [,1] [,2] [,3] [,4]
## [1,]    5    6    2    5
## [2,]    7    9    1    7
## [3,]    1    5    9    5

matrice1 * 3

##      [,1] [,2] [,3] [,4]
## [1,]   15   18    6   15
## [2,]   21   27    3   21
## [3,]    3   15   27   15

# rep (10,12) ripete il numero 10 per 12 volte
matrice2 <- matrix (rep(10,12),nrow=3, ncol=4)
matrice2

##      [,1] [,2] [,3] [,4]
## [1,]   10   10   10   10
## [2,]   10   10   10   10
## [3,]   10   10   10   10

# sommo ogni elemento di matrice1 al
# corrispondente di matrice2
matrice1+matrice2

##      [,1] [,2] [,3] [,4]
## [1,]   15   16   12   15
## [2,]   17   19   11   17
## [3,]   11   15   19   15

# sottraggo, elmento per elemento
matrice1-matrice2

##      [,1] [,2] [,3] [,4]
## [1,]   -5   -4   -8   -5
## [2,]   -3   -1   -9   -3
## [3,]   -9   -5   -1   -5

# divido
matrice1/matrice2

##      [,1] [,2] [,3] [,4]
## [1,]  0.5  0.6  0.2  0.5
## [2,]  0.7  0.9  0.1  0.7
## [3,]  0.1  0.5  0.9  0.5

matrice3 <- matrix(
	c(2,3,4,3,2,6,7,8,5,9,5,6),
	nrow=4,ncol=3, byrow=TRUE)
matrice3

##      [,1] [,2] [,3]
## [1,]    2    3    4
## [2,]    3    2    6
## [3,]    7    8    5
## [4,]    9    5    6

# traspongo matrice2 e la sommo a matrice3
t(matrice2)+matrice3

##      [,1] [,2] [,3]
## [1,]   12   13   14
## [2,]   13   12   16
## [3,]   17   18   15
## [4,]   19   15   16

Risorse

Programmazione funzionale

Functional programming · Advanced R.

le funzioni *apply

Data una matrice, la funzione apply(matrice,margine,funzione) applica la funzione ad ogni cella delle righe o delle colonne della matrice.

matrice1 <- matrix(sample(1:10,20,replace = TRUE),nrow = 5, ncol = 4)
matrice1

##      [,1] [,2] [,3] [,4]
## [1,]    2    9    6    3
## [2,]    2    5    4    9
## [3,]    5    1    5    9
## [4,]    5    2    1    8
## [5,]    4    7    8   10

# calcola la somma dei valori di ogni riga
apply(matrice1, 1, sum)

## [1] 20 20 20 16 29

# calcola la media di ogni colonna
apply(matrice1, 2, mean)

## [1] 3.6 4.8 4.8 7.8

sapply(lista,funzione) applica la funzione agli elementi della lista

lista1 <- list(a = 1:10, b = 11:20)
lista1

## $a
##  [1]  1  2  3  4  5  6  7  8  9 10
## 
## $b
##  [1] 11 12 13 14 15 16 17 18 19 20

sapply(lista1, mean)

##    a    b 
##  5.5 15.5

replicate(3, c(1:5))

##      [,1] [,2] [,3]
## [1,]    1    1    1
## [2,]    2    2    2
## [3,]    3    3    3
## [4,]    4    4    4
## [5,]    5    5    5

Riferimenti

Cookies

Questo sito utilizza cookies tecnici e di terze parti quali google analytics per funzionalità tecniche e statistiche.

Se non acconsenti all'utilizzo dei cookie di terze parti, alcune di queste funzionalità potrebbero essere non disponibili.